/**
 *
 * Copyright (C) 2004 Zack Rusin <zack@kde.org>
 * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301  USA
 */

#include "config.h"
#include "CSSComputedStyleDeclaration.h"

#include "CSSMutableStyleDeclaration.h"
#include "CSSPrimitiveValue.h"
#include "CSSPropertyNames.h"
#include "CSSValueKeywords.h"
#include "CSSValueList.h"
#include "CachedImage.h"
#include "DashboardRegion.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "Pair.h"
#include "RenderObject.h"
#include "ShadowValue.h"

namespace WebCore {

// List of all properties we know how to compute, omitting shorthands.
static const int computedProperties[] = {
    CSS_PROP_BACKGROUND_ATTACHMENT,
    CSS_PROP_BACKGROUND_COLOR,
    CSS_PROP_BACKGROUND_IMAGE,
    // more specific background-position-x/y are non-standard
    CSS_PROP_BACKGROUND_POSITION,
    CSS_PROP_BACKGROUND_REPEAT,
    CSS_PROP_BORDER_BOTTOM_COLOR,
    CSS_PROP_BORDER_BOTTOM_STYLE,
    CSS_PROP_BORDER_BOTTOM_WIDTH,
    CSS_PROP_BORDER_COLLAPSE,
    CSS_PROP_BORDER_LEFT_COLOR,
    CSS_PROP_BORDER_LEFT_STYLE,
    CSS_PROP_BORDER_LEFT_WIDTH,
    CSS_PROP_BORDER_RIGHT_COLOR,
    CSS_PROP_BORDER_RIGHT_STYLE,
    CSS_PROP_BORDER_RIGHT_WIDTH,
    CSS_PROP_BORDER_TOP_COLOR,
    CSS_PROP_BORDER_TOP_STYLE,
    CSS_PROP_BORDER_TOP_WIDTH,
    CSS_PROP_BOTTOM,
    CSS_PROP_CAPTION_SIDE,
    CSS_PROP_CLEAR,
    CSS_PROP_COLOR,
    CSS_PROP_CURSOR,
    CSS_PROP_DIRECTION,
    CSS_PROP_DISPLAY,
    CSS_PROP_EMPTY_CELLS,
    CSS_PROP_FLOAT,
    CSS_PROP_FONT_FAMILY,
    CSS_PROP_FONT_SIZE,
    CSS_PROP_FONT_STYLE,
    CSS_PROP_FONT_VARIANT,
    CSS_PROP_FONT_WEIGHT,
    CSS_PROP_HEIGHT,
    CSS_PROP_LEFT,
    CSS_PROP_LETTER_SPACING,
    CSS_PROP_LINE_HEIGHT,
    CSS_PROP_LIST_STYLE_IMAGE,
    CSS_PROP_LIST_STYLE_POSITION,
    CSS_PROP_LIST_STYLE_TYPE,
    CSS_PROP_MARGIN_BOTTOM,
    CSS_PROP_MARGIN_LEFT,
    CSS_PROP_MARGIN_RIGHT,
    CSS_PROP_MARGIN_TOP,
    CSS_PROP_MAX_HEIGHT,
    CSS_PROP_MAX_WIDTH,
    CSS_PROP_MIN_HEIGHT,
    CSS_PROP_MIN_WIDTH,
    CSS_PROP_OPACITY,
    CSS_PROP_ORPHANS,
    CSS_PROP_OUTLINE_COLOR,
    CSS_PROP_OUTLINE_STYLE,
    CSS_PROP_OUTLINE_WIDTH,
    CSS_PROP_OVERFLOW_X,
    CSS_PROP_OVERFLOW_Y,
    CSS_PROP_PADDING_BOTTOM,
    CSS_PROP_PADDING_LEFT,
    CSS_PROP_PADDING_RIGHT,
    CSS_PROP_PADDING_TOP,
    CSS_PROP_PAGE_BREAK_AFTER,
    CSS_PROP_PAGE_BREAK_BEFORE,
    CSS_PROP_PAGE_BREAK_INSIDE,
    CSS_PROP_POSITION,
    CSS_PROP_RESIZE,
    CSS_PROP_RIGHT,
    CSS_PROP_TABLE_LAYOUT,
    CSS_PROP_TEXT_ALIGN,
    CSS_PROP_TEXT_DECORATION,
    CSS_PROP_TEXT_INDENT,
    CSS_PROP_TEXT_SHADOW,
    CSS_PROP_TEXT_TRANSFORM,
    CSS_PROP_TOP,
    CSS_PROP_UNICODE_BIDI,
    CSS_PROP_VERTICAL_ALIGN,
    CSS_PROP_VISIBILITY,
    CSS_PROP_WHITE_SPACE,
    CSS_PROP_WIDOWS,
    CSS_PROP_WIDTH,
    CSS_PROP_WORD_SPACING,
    CSS_PROP_WORD_WRAP,
    CSS_PROP_Z_INDEX,

    CSS_PROP__WEBKIT_APPEARANCE,
    CSS_PROP__WEBKIT_BACKGROUND_CLIP,
    CSS_PROP__WEBKIT_BACKGROUND_COMPOSITE,
    CSS_PROP__WEBKIT_BACKGROUND_ORIGIN,
    CSS_PROP__WEBKIT_BACKGROUND_SIZE,
    CSS_PROP__WEBKIT_BORDER_FIT,
    CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING,
    CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING,
    CSS_PROP__WEBKIT_BOX_ALIGN,
    CSS_PROP__WEBKIT_BOX_DIRECTION,
    CSS_PROP__WEBKIT_BOX_FLEX,
    CSS_PROP__WEBKIT_BOX_FLEX_GROUP,
    CSS_PROP__WEBKIT_BOX_LINES,
    CSS_PROP__WEBKIT_BOX_ORDINAL_GROUP,
    CSS_PROP__WEBKIT_BOX_ORIENT,
    CSS_PROP__WEBKIT_BOX_PACK,
    CSS_PROP__WEBKIT_BOX_SHADOW,
    CSS_PROP__WEBKIT_BOX_SIZING,
    CSS_PROP__WEBKIT_COLUMN_BREAK_AFTER,
    CSS_PROP__WEBKIT_COLUMN_BREAK_BEFORE,
    CSS_PROP__WEBKIT_COLUMN_BREAK_INSIDE,
    CSS_PROP__WEBKIT_COLUMN_COUNT,
    CSS_PROP__WEBKIT_COLUMN_GAP,
    CSS_PROP__WEBKIT_COLUMN_RULE_COLOR,
    CSS_PROP__WEBKIT_COLUMN_RULE_STYLE,
    CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH,
    CSS_PROP__WEBKIT_COLUMN_WIDTH,
    CSS_PROP__WEBKIT_HIGHLIGHT,
    CSS_PROP__WEBKIT_LINE_BREAK,
    CSS_PROP__WEBKIT_LINE_CLAMP,
    CSS_PROP__WEBKIT_MARGIN_BOTTOM_COLLAPSE,
    CSS_PROP__WEBKIT_MARGIN_TOP_COLLAPSE,
    CSS_PROP__WEBKIT_MARQUEE_DIRECTION,
    CSS_PROP__WEBKIT_MARQUEE_INCREMENT,
    CSS_PROP__WEBKIT_MARQUEE_REPETITION,
    CSS_PROP__WEBKIT_MARQUEE_STYLE,
    CSS_PROP__WEBKIT_NBSP_MODE,
    CSS_PROP__WEBKIT_RTL_ORDERING,
    CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT,
    CSS_PROP__WEBKIT_TEXT_FILL_COLOR,
    CSS_PROP__WEBKIT_TEXT_SECURITY,
    CSS_PROP__WEBKIT_TEXT_STROKE_COLOR,
    CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH,
    CSS_PROP__WEBKIT_USER_DRAG,
    CSS_PROP__WEBKIT_USER_MODIFY,
    CSS_PROP__WEBKIT_USER_SELECT,
    CSS_PROP__WEBKIT_DASHBOARD_REGION,
    CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS,
    CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS,
    CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS,
    CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS
};

const unsigned numComputedProperties = sizeof(computedProperties) / sizeof(computedProperties[0]);

static PassRefPtr<CSSValue> valueForLength(const Length& length)
{
    switch (length.type()) {
        case Auto:
            return new CSSPrimitiveValue(CSS_VAL_AUTO);
        case WebCore::Fixed:
            return new CSSPrimitiveValue(length.value(), CSSPrimitiveValue::CSS_PX);
        case Intrinsic:
            return new CSSPrimitiveValue(CSS_VAL_INTRINSIC);
        case MinIntrinsic:
            return new CSSPrimitiveValue(CSS_VAL_MIN_INTRINSIC);
        case Percent:
            return new CSSPrimitiveValue(length.percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
        case Relative:
        case Static:
            break;
    }
    ASSERT_NOT_REACHED();
    return 0;
}

// Handles special value for "none".
static PassRefPtr<CSSValue> valueForMaxLength(const Length& length)
{
    if (length.isFixed() && length.value() == undefinedLength)
        return new CSSPrimitiveValue(CSS_VAL_NONE);
    return valueForLength(length);
}

static PassRefPtr<CSSValue> valueForBorderStyle(EBorderStyle style)
{
    switch (style) {
        case BNONE:
            return new CSSPrimitiveValue(CSS_VAL_NONE);
        case BHIDDEN:
            return new CSSPrimitiveValue(CSS_VAL_HIDDEN);
        case INSET:
            return new CSSPrimitiveValue(CSS_VAL_INSET);
        case GROOVE:
            return new CSSPrimitiveValue(CSS_VAL_GROOVE);
        case RIDGE:
            return new CSSPrimitiveValue(CSS_VAL_RIDGE);
        case OUTSET:
            return new CSSPrimitiveValue(CSS_VAL_OUTSET);
        case DOTTED:
            return new CSSPrimitiveValue(CSS_VAL_DOTTED);
        case DASHED:
            return new CSSPrimitiveValue(CSS_VAL_DASHED);
        case SOLID:
            return new CSSPrimitiveValue(CSS_VAL_SOLID);
        case DOUBLE:
            return new CSSPrimitiveValue(CSS_VAL_DOUBLE);
    }
    ASSERT_NOT_REACHED();
    return 0;
}

static PassRefPtr<CSSValue> valueForTextAlign(ETextAlign align)
{
    switch (align) {
        case TAAUTO:
            return new CSSPrimitiveValue(CSS_VAL_AUTO);
        case LEFT:
            return new CSSPrimitiveValue(CSS_VAL_LEFT);
        case RIGHT:
            return new CSSPrimitiveValue(CSS_VAL_RIGHT);
        case CENTER:
            return new CSSPrimitiveValue(CSS_VAL_CENTER);
        case JUSTIFY:
            return new CSSPrimitiveValue(CSS_VAL_JUSTIFY);
        case WEBKIT_LEFT:
            return new CSSPrimitiveValue(CSS_VAL__WEBKIT_LEFT);
        case WEBKIT_RIGHT:
            return new CSSPrimitiveValue(CSS_VAL__WEBKIT_RIGHT);
        case WEBKIT_CENTER:
            return new CSSPrimitiveValue(CSS_VAL__WEBKIT_CENTER);
    }
    ASSERT_NOT_REACHED();
    return 0;
}

static PassRefPtr<CSSValue> valueForAppearance(EAppearance appearance)
{
    switch (appearance) {
        case NoAppearance:
            return new CSSPrimitiveValue(CSS_VAL_NONE);
        case CheckboxAppearance:
            return new CSSPrimitiveValue(CSS_VAL_CHECKBOX);
        case RadioAppearance:
            return new CSSPrimitiveValue(CSS_VAL_RADIO);
        case PushButtonAppearance:
            return new CSSPrimitiveValue(CSS_VAL_PUSH_BUTTON);
        case SquareButtonAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SQUARE_BUTTON);
        case ButtonAppearance:
            return new CSSPrimitiveValue(CSS_VAL_BUTTON);
        case ButtonBevelAppearance:
            return new CSSPrimitiveValue(CSS_VAL_BUTTON_BEVEL);
        case ListboxAppearance:
            return new CSSPrimitiveValue(CSS_VAL_LISTBOX);
        case ListItemAppearance:
            return new CSSPrimitiveValue(CSS_VAL_LISTITEM);
        case MenulistAppearance:
            return new CSSPrimitiveValue(CSS_VAL_MENULIST);
        case MenulistButtonAppearance:
            return new CSSPrimitiveValue(CSS_VAL_MENULIST_BUTTON);
        case MenulistTextAppearance:
            return new CSSPrimitiveValue(CSS_VAL_MENULIST_TEXT);
        case MenulistTextFieldAppearance:
            return new CSSPrimitiveValue(CSS_VAL_MENULIST_TEXTFIELD);
        case ScrollbarButtonUpAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARBUTTON_UP);
        case ScrollbarButtonDownAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARBUTTON_DOWN);
        case ScrollbarButtonLeftAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARBUTTON_LEFT);
        case ScrollbarButtonRightAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARBUTTON_RIGHT);
        case ScrollbarTrackHorizontalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARTRACK_HORIZONTAL);
        case ScrollbarTrackVerticalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARTRACK_VERTICAL);
        case ScrollbarThumbHorizontalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARTHUMB_HORIZONTAL);
        case ScrollbarThumbVerticalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARTHUMB_VERTICAL);
        case ScrollbarGripperHorizontalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARGRIPPER_HORIZONTAL);
        case ScrollbarGripperVerticalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SCROLLBARGRIPPER_VERTICAL);
        case SliderHorizontalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SLIDER_HORIZONTAL);
        case SliderVerticalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SLIDER_VERTICAL);
        case SliderThumbHorizontalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SLIDERTHUMB_HORIZONTAL);
        case SliderThumbVerticalAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SLIDERTHUMB_VERTICAL);
        case CaretAppearance:
            return new CSSPrimitiveValue(CSS_VAL_CARET);
        case SearchFieldAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD);
        case SearchFieldDecorationAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD_DECORATION);
        case SearchFieldResultsDecorationAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD_RESULTS_DECORATION);
        case SearchFieldResultsButtonAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD_RESULTS_BUTTON);
        case SearchFieldCancelButtonAppearance:
            return new CSSPrimitiveValue(CSS_VAL_SEARCHFIELD_CANCEL_BUTTON);
        case TextFieldAppearance:
            return new CSSPrimitiveValue(CSS_VAL_TEXTFIELD);
        case TextAreaAppearance:
            return new CSSPrimitiveValue(CSS_VAL_TEXTAREA);
    }
    ASSERT_NOT_REACHED();
    return 0;
}

static PassRefPtr<CSSValue> valueForMarginCollapse(EMarginCollapse collapse)
{
    switch (collapse) {
        case MCOLLAPSE:
            return new CSSPrimitiveValue(CSS_VAL_COLLAPSE);
        case MSEPARATE:
            return new CSSPrimitiveValue(CSS_VAL_SEPARATE);
        case MDISCARD:
            return new CSSPrimitiveValue(CSS_VAL_DISCARD);
    }
    ASSERT_NOT_REACHED();
    return 0;
}

static PassRefPtr<CSSValue> valueForShadow(const ShadowData* shadow)
{
    if (!shadow)
        return new CSSPrimitiveValue(CSS_VAL_NONE);

    RefPtr<CSSValueList> list = new CSSValueList;
    for (const ShadowData* s = shadow; s; s = s->next) {
        RefPtr<CSSPrimitiveValue> x = new CSSPrimitiveValue(s->x, CSSPrimitiveValue::CSS_PX);
        RefPtr<CSSPrimitiveValue> y = new CSSPrimitiveValue(s->y, CSSPrimitiveValue::CSS_PX);
        RefPtr<CSSPrimitiveValue> blur = new CSSPrimitiveValue(s->blur, CSSPrimitiveValue::CSS_PX);
        RefPtr<CSSPrimitiveValue> color = new CSSPrimitiveValue(s->color.rgb());
        list->append(new ShadowValue(x.release(), y.release(), blur.release(), color.release()));
    }
    return list.release();
}

static PassRefPtr<CSSValue> getPositionOffsetValue(RenderStyle* style, int propertyID)
{
    if (!style)
        return 0;

    Length l;
    switch (propertyID) {
        case CSS_PROP_LEFT:
            l = style->left();
            break;
        case CSS_PROP_RIGHT:
            l = style->right();
            break;
        case CSS_PROP_TOP:
            l = style->top();
            break;
        case CSS_PROP_BOTTOM:
            l = style->bottom();
            break;
        default:
            return 0;
    }

    if (style->position() == AbsolutePosition || style->position() == FixedPosition)
        return valueForLength(l);

    if (style->position() == RelativePosition)
        // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
        // In other words if left is auto and right is not auto, then left's computed value is negative right.
        // So we should get the opposite length unit and see if it is auto.
        return valueForLength(l);

    return new CSSPrimitiveValue(CSS_VAL_AUTO);
}

static PassRefPtr<CSSPrimitiveValue> currentColorOrValidColor(RenderStyle* style, const Color& color)
{
    if (!color.isValid())
        return new CSSPrimitiveValue(style->color().rgb());
    return new CSSPrimitiveValue(color.rgb());
}

static PassRefPtr<CSSValue> getBorderRadiusCornerValue(IntSize radius)
{
    if (radius.width() == radius.height())
        return new CSSPrimitiveValue(radius.width(), CSSPrimitiveValue::CSS_PX);

    RefPtr<CSSValueList> list = new CSSValueList(true);
    list->append(new CSSPrimitiveValue(radius.width(), CSSPrimitiveValue::CSS_PX));
    list->append(new CSSPrimitiveValue(radius.height(), CSSPrimitiveValue::CSS_PX));
    return list.release();
}

static IntRect sizingBox(RenderObject* renderer)
{
    return renderer->style()->boxSizing() == CONTENT_BOX ? renderer->contentBox() : renderer->borderBox();
}

CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n)
    : m_node(n)
{
}

CSSComputedStyleDeclaration::~CSSComputedStyleDeclaration()
{
}

String CSSComputedStyleDeclaration::cssText() const
{
    String result("");

    for (unsigned i = 0; i < numComputedProperties; i++) {
        if (i)
            result += " ";
        result += getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));
        result += ": ";
        result += getPropertyValue(computedProperties[i]);
        result += ";";
    }

    return result;
}

void CSSComputedStyleDeclaration::setCssText(const String&, ExceptionCode& ec)
{
    ec = NO_MODIFICATION_ALLOWED_ERR;
}

// Display integers in integer format instead of "1.0".
static String numberAsString(double n)
{
    long i = static_cast<long>(n);
    return i == n ? String::number(i) : String::number(n);
}

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID) const
{
    return getPropertyCSSValue(propertyID, UpdateLayout);
}

PassRefPtr<CSSPrimitiveValue> primitiveValueFromLength(Length length)
{
    String string;
    switch (length.type()) {
        case Percent:
            string = numberAsString(length.percent()) + "%";
            break;
        case Fixed:
            string = numberAsString(length.calcMinValue(0));
            break;
        case Auto:
            string = "auto";
            break;
        default:
            break;
    }
    return new CSSPrimitiveValue(string, CSSPrimitiveValue::CSS_STRING);
}

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID, EUpdateLayout updateLayout) const
{
    Node* node = m_node.get();
    if (!node)
        return 0;

    // Make sure our layout is up to date before we allow a query on these attributes.
    if (updateLayout)
        node->document()->updateLayout();

    RenderObject* renderer = node->renderer();

    RenderStyle* style = node->computedStyle();
    if (!style)
        return 0;

    switch (static_cast<CSSPropertyID>(propertyID)) {
        case CSS_PROP_INVALID:
            break;

        case CSS_PROP_BACKGROUND_COLOR:
            return new CSSPrimitiveValue(style->backgroundColor().rgb());
        case CSS_PROP_BACKGROUND_IMAGE:
            if (style->backgroundImage())
                return new CSSPrimitiveValue(style->backgroundImage()->url(), CSSPrimitiveValue::CSS_URI);
            return new CSSPrimitiveValue(CSS_VAL_NONE);
        case CSS_PROP__WEBKIT_BACKGROUND_SIZE: {
            RefPtr<CSSValueList> list = new CSSValueList(true);
            list->append(valueForLength(style->backgroundSize().width));
            list->append(valueForLength(style->backgroundSize().height));
            return list.release();
        }  
        case CSS_PROP_BACKGROUND_REPEAT:
            switch (style->backgroundRepeat()) {
                case REPEAT:
                    return new CSSPrimitiveValue(CSS_VAL_REPEAT);
                case REPEAT_X:
                    return new CSSPrimitiveValue(CSS_VAL_REPEAT_X);
                case REPEAT_Y:
                    return new CSSPrimitiveValue(CSS_VAL_REPEAT_Y);
                case NO_REPEAT:
                    return new CSSPrimitiveValue(CSS_VAL_NO_REPEAT);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_BACKGROUND_COMPOSITE:
            switch (style->backgroundComposite()) {
                case CompositeClear:
                    return new CSSPrimitiveValue(CSS_VAL_CLEAR);
                case CompositeCopy:
                    return new CSSPrimitiveValue(CSS_VAL_COPY);
                case CompositeSourceOver:
                    return new CSSPrimitiveValue(CSS_VAL_SOURCE_OVER);
                case CompositeSourceIn:
                    return new CSSPrimitiveValue(CSS_VAL_SOURCE_IN);
                case CompositeSourceOut:
                    return new CSSPrimitiveValue(CSS_VAL_SOURCE_OUT);
                case CompositeSourceAtop:
                    return new CSSPrimitiveValue(CSS_VAL_SOURCE_ATOP);
                case CompositeDestinationOver:
                    return new CSSPrimitiveValue(CSS_VAL_DESTINATION_OVER);
                case CompositeDestinationIn:
                    return new CSSPrimitiveValue(CSS_VAL_DESTINATION_IN);
                case CompositeDestinationOut:
                    return new CSSPrimitiveValue(CSS_VAL_DESTINATION_OUT);
                case CompositeDestinationAtop:
                    return new CSSPrimitiveValue(CSS_VAL_DESTINATION_ATOP);
                case CompositeXOR:
                    return new CSSPrimitiveValue(CSS_VAL_XOR);
                case CompositePlusDarker:
                    return new CSSPrimitiveValue(CSS_VAL_PLUS_DARKER);
                case CompositeHighlight:
                    return new CSSPrimitiveValue(CSS_VAL_HIGHLIGHT);
                case CompositePlusLighter:
                    return new CSSPrimitiveValue(CSS_VAL_PLUS_LIGHTER);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_BACKGROUND_ATTACHMENT:
            if (style->backgroundAttachment())
                return new CSSPrimitiveValue(CSS_VAL_SCROLL);
            return new CSSPrimitiveValue(CSS_VAL_FIXED);
        case CSS_PROP__WEBKIT_BACKGROUND_CLIP:
        case CSS_PROP__WEBKIT_BACKGROUND_ORIGIN: {
            EBackgroundBox box = (propertyID == CSS_PROP__WEBKIT_BACKGROUND_CLIP ? style->backgroundClip() : style->backgroundOrigin());
            switch (box) {
                case BGBORDER:
                    return new CSSPrimitiveValue(CSS_VAL_BORDER);
                case BGPADDING:
                    return new CSSPrimitiveValue(CSS_VAL_PADDING);
                case BGCONTENT:
                    return new CSSPrimitiveValue(CSS_VAL_CONTENT);
            }
            ASSERT_NOT_REACHED();
            return 0;
        }
        case CSS_PROP_BACKGROUND_POSITION: {
            RefPtr<CSSValueList> list = new CSSValueList(true);

            Length length(style->backgroundXPosition());
            if (length.isPercent())
                list->append(new CSSPrimitiveValue(length.percent(), CSSPrimitiveValue::CSS_PERCENTAGE));
            else
                list->append(new CSSPrimitiveValue(length.value(), CSSPrimitiveValue::CSS_PX));

            length = style->backgroundYPosition();
            if (length.isPercent())
                list->append(new CSSPrimitiveValue(length.percent(), CSSPrimitiveValue::CSS_PERCENTAGE));
            else
                list->append(new CSSPrimitiveValue(length.value(), CSSPrimitiveValue::CSS_PX));

            return list.release();
        }
        case CSS_PROP_BACKGROUND_POSITION_X: {
            Length length(style->backgroundXPosition());
            if (length.isPercent())
                return new CSSPrimitiveValue(length.percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
            else
                return new CSSPrimitiveValue(length.value(), CSSPrimitiveValue::CSS_PX);
        }
        case CSS_PROP_BACKGROUND_POSITION_Y: {
            Length length(style->backgroundYPosition());
            if (length.isPercent())
                return new CSSPrimitiveValue(length.percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
            else
                return new CSSPrimitiveValue(length.value(), CSSPrimitiveValue::CSS_PX);
        }
        case CSS_PROP_BORDER_COLLAPSE:
            if (style->borderCollapse())
                return new CSSPrimitiveValue(CSS_VAL_COLLAPSE);
            return new CSSPrimitiveValue(CSS_VAL_SEPARATE);
        case CSS_PROP_BORDER_SPACING: {
            RefPtr<CSSValueList> list = new CSSValueList(true);
            list->append(new CSSPrimitiveValue(style->horizontalBorderSpacing(), CSSPrimitiveValue::CSS_PX));
            list->append(new CSSPrimitiveValue(style->verticalBorderSpacing(), CSSPrimitiveValue::CSS_PX));
            return list.release();
        }  
        case CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING:
            return new CSSPrimitiveValue(style->horizontalBorderSpacing(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING:
            return new CSSPrimitiveValue(style->verticalBorderSpacing(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BORDER_TOP_COLOR:
            return currentColorOrValidColor(style, style->borderTopColor());
        case CSS_PROP_BORDER_RIGHT_COLOR:
            return currentColorOrValidColor(style, style->borderRightColor());
        case CSS_PROP_BORDER_BOTTOM_COLOR:
            return currentColorOrValidColor(style, style->borderBottomColor());
        case CSS_PROP_BORDER_LEFT_COLOR:
            return currentColorOrValidColor(style, style->borderLeftColor());
        case CSS_PROP_BORDER_TOP_STYLE:
            return valueForBorderStyle(style->borderTopStyle());
        case CSS_PROP_BORDER_RIGHT_STYLE:
            return valueForBorderStyle(style->borderRightStyle());
        case CSS_PROP_BORDER_BOTTOM_STYLE:
            return valueForBorderStyle(style->borderBottomStyle());
        case CSS_PROP_BORDER_LEFT_STYLE:
            return valueForBorderStyle(style->borderLeftStyle());
        case CSS_PROP_BORDER_TOP_WIDTH:
            return new CSSPrimitiveValue(style->borderTopWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BORDER_RIGHT_WIDTH:
            return new CSSPrimitiveValue(style->borderRightWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BORDER_BOTTOM_WIDTH:
            return new CSSPrimitiveValue(style->borderBottomWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BORDER_LEFT_WIDTH:
            return new CSSPrimitiveValue(style->borderLeftWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_BOTTOM:
            return getPositionOffsetValue(style, CSS_PROP_BOTTOM);
        case CSS_PROP__WEBKIT_BOX_ALIGN:
            switch (style->boxAlign()) {
                case BSTRETCH:
                    return new CSSPrimitiveValue(CSS_VAL_STRETCH);
                case BSTART:
                    return new CSSPrimitiveValue(CSS_VAL_START);
                case BCENTER:
                    return new CSSPrimitiveValue(CSS_VAL_CENTER);
                case BEND:
                    return new CSSPrimitiveValue(CSS_VAL_END);
                case BBASELINE:
                    return new CSSPrimitiveValue(CSS_VAL_BASELINE);
                case BJUSTIFY:
                    break; // not allowed
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_BOX_DIRECTION:
            switch (style->boxDirection()) {
                case BNORMAL:
                    return new CSSPrimitiveValue(CSS_VAL_NORMAL);
                case BREVERSE:
                    return new CSSPrimitiveValue(CSS_VAL_REVERSE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_BOX_FLEX:
            return new CSSPrimitiveValue(style->boxFlex(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_BOX_FLEX_GROUP:
            return new CSSPrimitiveValue(style->boxFlexGroup(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_BOX_LINES:
            switch (style->boxLines()) {
                case SINGLE:
                    return new CSSPrimitiveValue(CSS_VAL_SINGLE);
                case MULTIPLE:
                    return new CSSPrimitiveValue(CSS_VAL_MULTIPLE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_BOX_ORDINAL_GROUP:
            return new CSSPrimitiveValue(style->boxOrdinalGroup(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_BOX_ORIENT:
            switch (style->boxOrient()) {
                case HORIZONTAL:
                    return new CSSPrimitiveValue(CSS_VAL_HORIZONTAL);
                case VERTICAL:
                    return new CSSPrimitiveValue(CSS_VAL_VERTICAL);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_BOX_PACK:
            switch (style->boxPack()) {
                case BSTART:
                    return new CSSPrimitiveValue(CSS_VAL_START);
                case BEND:
                    return new CSSPrimitiveValue(CSS_VAL_END);
                case BCENTER:
                    return new CSSPrimitiveValue(CSS_VAL_CENTER);
                case BJUSTIFY:
                    return new CSSPrimitiveValue(CSS_VAL_JUSTIFY);
                case BSTRETCH:
                case BBASELINE:
                    break; // not allowed
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_BOX_SHADOW:
            return valueForShadow(style->boxShadow());
        case CSS_PROP_CAPTION_SIDE:
            switch (style->captionSide()) {
                case CAPLEFT:
                    return new CSSPrimitiveValue(CSS_VAL_LEFT);
                case CAPRIGHT:
                    return new CSSPrimitiveValue(CSS_VAL_RIGHT);
                case CAPTOP:
                    return new CSSPrimitiveValue(CSS_VAL_TOP);
                case CAPBOTTOM:
                    return new CSSPrimitiveValue(CSS_VAL_BOTTOM);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_CLEAR:
            switch (style->clear()) {
                case CNONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
                case CLEFT:
                    return new CSSPrimitiveValue(CSS_VAL_LEFT);
                case CRIGHT:
                    return new CSSPrimitiveValue(CSS_VAL_RIGHT);
                case CBOTH:
                    return new CSSPrimitiveValue(CSS_VAL_BOTH);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_COLOR:
            return new CSSPrimitiveValue(style->color().rgb());
        case CSS_PROP__WEBKIT_COLUMN_COUNT:
            if (style->hasAutoColumnCount())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return new CSSPrimitiveValue(style->columnCount(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_COLUMN_GAP:
            if (style->hasNormalColumnGap())
                return new CSSPrimitiveValue(CSS_VAL_NORMAL);
            return new CSSPrimitiveValue(style->columnGap(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_COLUMN_RULE_COLOR:
            return currentColorOrValidColor(style, style->columnRuleColor());
        case CSS_PROP__WEBKIT_COLUMN_RULE_STYLE:
            return valueForBorderStyle(style->columnRuleStyle());
        case CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH:
            return new CSSPrimitiveValue(style->columnRuleWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_COLUMN_BREAK_AFTER:
            switch (style->columnBreakAfter()) {
                case PBAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case PBALWAYS:
                    return new CSSPrimitiveValue(CSS_VAL_ALWAYS);
                case PBAVOID:
                    return new CSSPrimitiveValue(CSS_VAL_AVOID);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_COLUMN_BREAK_BEFORE:
            switch (style->columnBreakBefore()) {
                case PBAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case PBALWAYS:
                    return new CSSPrimitiveValue(CSS_VAL_ALWAYS);
                case PBAVOID:
                    return new CSSPrimitiveValue(CSS_VAL_AVOID);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_COLUMN_BREAK_INSIDE:
            switch (style->columnBreakInside()) {
                case PBAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case PBAVOID:
                    return new CSSPrimitiveValue(CSS_VAL_AVOID);
                case PBALWAYS:
                    break; // not allowed
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_COLUMN_WIDTH:
            if (style->hasAutoColumnWidth())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return new CSSPrimitiveValue(style->columnWidth(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_CURSOR: {
            RefPtr<CSSValueList> list;
            CursorList* cursors = style->cursors();
            if (cursors && cursors->size() > 0) {
                list = new CSSValueList;
                for (unsigned i = 0; i < cursors->size(); ++i)
                    list->append(new CSSPrimitiveValue((*cursors)[i].cursorImage->url(), CSSPrimitiveValue::CSS_URI));
            }
            RefPtr<CSSValue> value;
            switch (style->cursor()) {
                case CURSOR_AUTO:
                    value = new CSSPrimitiveValue(CSS_VAL_AUTO);
                    break;
                case CURSOR_CROSS:
                    value = new CSSPrimitiveValue(CSS_VAL_CROSSHAIR);
                    break;
                case CURSOR_DEFAULT:
                    value = new CSSPrimitiveValue(CSS_VAL_DEFAULT);
                    break;
                case CURSOR_POINTER:
                    value = new CSSPrimitiveValue(CSS_VAL_POINTER);
                    break;
                case CURSOR_MOVE:
                    value = new CSSPrimitiveValue(CSS_VAL_MOVE);
                    break;
                case CURSOR_CELL:
                    value = new CSSPrimitiveValue(CSS_VAL_CELL);
                    break;
                case CURSOR_VERTICAL_TEXT:
                    value = new CSSPrimitiveValue(CSS_VAL_VERTICAL_TEXT);
                    break;
                case CURSOR_CONTEXT_MENU:
                    value = new CSSPrimitiveValue(CSS_VAL_CONTEXT_MENU);
                    break;
                case CURSOR_ALIAS:
                    value = new CSSPrimitiveValue(CSS_VAL_ALIAS);
                    break;
                case CURSOR_COPY:
                    value = new CSSPrimitiveValue(CSS_VAL_COPY);
                    break;
                case CURSOR_NONE:
                    value = new CSSPrimitiveValue(CSS_VAL_NONE);
                    break;
                case CURSOR_PROGRESS:
                    value = new CSSPrimitiveValue(CSS_VAL_PROGRESS);
                    break;
                case CURSOR_NO_DROP:
                    value = new CSSPrimitiveValue(CSS_VAL_NO_DROP);
                    break;
                case CURSOR_NOT_ALLOWED:
                    value = new CSSPrimitiveValue(CSS_VAL_NOT_ALLOWED);
                    break;
                case CURSOR_WEBKIT_ZOOM_IN:
                    value = new CSSPrimitiveValue(CSS_VAL__WEBKIT_ZOOM_IN);
                    break;
                case CURSOR_WEBKIT_ZOOM_OUT:
                    value = new CSSPrimitiveValue(CSS_VAL__WEBKIT_ZOOM_OUT);
                    break;
                case CURSOR_E_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_E_RESIZE);
                    break;
                case CURSOR_NE_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_NE_RESIZE);
                    break;
                case CURSOR_NW_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_NW_RESIZE);
                    break;
                case CURSOR_N_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_N_RESIZE);
                    break;
                case CURSOR_SE_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_SE_RESIZE);
                    break;
                case CURSOR_SW_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_SW_RESIZE);
                    break;
                case CURSOR_S_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_S_RESIZE);
                    break;
                case CURSOR_W_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_W_RESIZE);
                    break;
                case CURSOR_EW_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_EW_RESIZE);
                    break;
                case CURSOR_NS_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_NS_RESIZE);
                    break;
                case CURSOR_NESW_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_NESW_RESIZE);
                    break;
                case CURSOR_NWSE_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_NWSE_RESIZE);
                    break;
                case CURSOR_COL_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_COL_RESIZE);
                    break;
                case CURSOR_ROW_RESIZE:
                    value = new CSSPrimitiveValue(CSS_VAL_ROW_RESIZE);
                    break;
                case CURSOR_TEXT:
                    value = new CSSPrimitiveValue(CSS_VAL_TEXT);
                    break;
                case CURSOR_WAIT:
                    value = new CSSPrimitiveValue(CSS_VAL_WAIT);
                    break;
                case CURSOR_HELP:
                    value = new CSSPrimitiveValue(CSS_VAL_HELP);
                    break;
                case CURSOR_ALL_SCROLL:
                    value = new CSSPrimitiveValue(CSS_VAL_ALL_SCROLL);
                    break;
            }
            ASSERT(value);
            if (list) {
                list->append(value);
                return list.release();
            }
            return value.release();
        }
        case CSS_PROP_DIRECTION:
            switch (style->direction()) {
                case LTR:
                    return new CSSPrimitiveValue(CSS_VAL_LTR);
                case RTL:
                    return new CSSPrimitiveValue(CSS_VAL_RTL);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_DISPLAY:
            switch (style->display()) {
                case INLINE:
                    return new CSSPrimitiveValue(CSS_VAL_INLINE);
                case BLOCK:
                    return new CSSPrimitiveValue(CSS_VAL_BLOCK);
                case LIST_ITEM:
                    return new CSSPrimitiveValue(CSS_VAL_LIST_ITEM);
                case RUN_IN:
                    return new CSSPrimitiveValue(CSS_VAL_RUN_IN);
                case COMPACT:
                    return new CSSPrimitiveValue(CSS_VAL_COMPACT);
                case INLINE_BLOCK:
                    return new CSSPrimitiveValue(CSS_VAL_INLINE_BLOCK);
                case TABLE:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE);
                case INLINE_TABLE:
                    return new CSSPrimitiveValue(CSS_VAL_INLINE_TABLE);
                case TABLE_ROW_GROUP:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE_ROW_GROUP);
                case TABLE_HEADER_GROUP:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE_HEADER_GROUP);
                case TABLE_FOOTER_GROUP:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE_FOOTER_GROUP);
                case TABLE_ROW:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE_ROW);
                case TABLE_COLUMN_GROUP:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE_COLUMN_GROUP);
                case TABLE_COLUMN:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE_COLUMN);
                case TABLE_CELL:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE_CELL);
                case TABLE_CAPTION:
                    return new CSSPrimitiveValue(CSS_VAL_TABLE_CAPTION);
                case BOX:
                    return new CSSPrimitiveValue(CSS_VAL__WEBKIT_BOX);
                case INLINE_BOX:
                    return new CSSPrimitiveValue(CSS_VAL__WEBKIT_INLINE_BOX);
                case NONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_EMPTY_CELLS:
            switch (style->emptyCells()) {
                case SHOW:
                    return new CSSPrimitiveValue(CSS_VAL_SHOW);
                case HIDE:
                    return new CSSPrimitiveValue(CSS_VAL_HIDE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_FLOAT:
            switch (style->floating()) {
                case FNONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
                case FLEFT:
                    return new CSSPrimitiveValue(CSS_VAL_LEFT);
                case FRIGHT:
                    return new CSSPrimitiveValue(CSS_VAL_RIGHT);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_FONT_FAMILY:
            // FIXME: This only returns the first family.
            return new CSSPrimitiveValue(style->fontDescription().family().family().domString(), CSSPrimitiveValue::CSS_STRING);
        case CSS_PROP_FONT_SIZE:
            return new CSSPrimitiveValue(style->fontDescription().computedPixelSize(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_BINDING:
            break;
        case CSS_PROP_FONT_STYLE:
            if (style->fontDescription().italic())
                return new CSSPrimitiveValue(CSS_VAL_ITALIC);
            return new CSSPrimitiveValue(CSS_VAL_NORMAL);
        case CSS_PROP_FONT_VARIANT:
            if (style->fontDescription().smallCaps())
                return new CSSPrimitiveValue(CSS_VAL_SMALL_CAPS);
            return new CSSPrimitiveValue(CSS_VAL_NORMAL);
        case CSS_PROP_FONT_WEIGHT:
            // FIXME: this does not reflect the full range of weights
            // that can be expressed with CSS
            if (style->fontDescription().weight() == cBoldWeight)
                return new CSSPrimitiveValue(CSS_VAL_BOLD);
            return new CSSPrimitiveValue(CSS_VAL_NORMAL);
        case CSS_PROP_HEIGHT:
            if (renderer)
                return new CSSPrimitiveValue(sizingBox(renderer).height(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->height());
        case CSS_PROP__WEBKIT_HIGHLIGHT:
            if (style->highlight() == nullAtom)
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(style->highlight(), CSSPrimitiveValue::CSS_STRING);
        case CSS_PROP__WEBKIT_BORDER_FIT:
            if (style->borderFit() == BorderFitBorder)
                return new CSSPrimitiveValue(CSS_VAL_BORDER);
            return new CSSPrimitiveValue(CSS_VAL_LINES);
        case CSS_PROP_LEFT:
            return getPositionOffsetValue(style, CSS_PROP_LEFT);
        case CSS_PROP_LETTER_SPACING:
            if (!style->letterSpacing())
                return new CSSPrimitiveValue(CSS_VAL_NORMAL);
            return new CSSPrimitiveValue(style->letterSpacing(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP__WEBKIT_LINE_CLAMP:
            if (style->lineClamp() == -1)
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(style->lineClamp(), CSSPrimitiveValue::CSS_PERCENTAGE);
        case CSS_PROP_LINE_HEIGHT: {
            Length length = style->lineHeight();
            if (length.isNegative())
                return new CSSPrimitiveValue(CSS_VAL_NORMAL);
            if (length.isPercent())
                // This is imperfect, because it doesn't include the zoom factor and the real computation
                // for how high to be in pixels does include things like minimum font size and the zoom factor.
                // On the other hand, since font-size doesn't include the zoom factor, we really can't do
                // that here either.
                return new CSSPrimitiveValue(static_cast<int>(length.percent() * style->fontDescription().specifiedSize()) / 100, CSSPrimitiveValue::CSS_PX);
            return new CSSPrimitiveValue(length.value(), CSSPrimitiveValue::CSS_PX);
        }
        case CSS_PROP_LIST_STYLE_IMAGE:
            if (style->listStyleImage())
                return new CSSPrimitiveValue(style->listStyleImage()->url(), CSSPrimitiveValue::CSS_URI);
            return new CSSPrimitiveValue(CSS_VAL_NONE);
        case CSS_PROP_LIST_STYLE_POSITION:
            switch (style->listStylePosition()) {
                case OUTSIDE:
                    return new CSSPrimitiveValue(CSS_VAL_OUTSIDE);
                case INSIDE:
                    return new CSSPrimitiveValue(CSS_VAL_INSIDE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_LIST_STYLE_TYPE:
            switch (style->listStyleType()) {
                case LNONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
                case DISC:
                    return new CSSPrimitiveValue(CSS_VAL_DISC);
                case CIRCLE:
                    return new CSSPrimitiveValue(CSS_VAL_CIRCLE);
                case SQUARE:
                    return new CSSPrimitiveValue(CSS_VAL_SQUARE);
                case LDECIMAL:
                    return new CSSPrimitiveValue(CSS_VAL_DECIMAL);
                case DECIMAL_LEADING_ZERO:
                    return new CSSPrimitiveValue(CSS_VAL_DECIMAL_LEADING_ZERO);
                case LOWER_ROMAN:
                    return new CSSPrimitiveValue(CSS_VAL_LOWER_ROMAN);
                case UPPER_ROMAN:
                    return new CSSPrimitiveValue(CSS_VAL_UPPER_ROMAN);
                case LOWER_GREEK:
                    return new CSSPrimitiveValue(CSS_VAL_LOWER_GREEK);
                case LOWER_ALPHA:
                    return new CSSPrimitiveValue(CSS_VAL_LOWER_ALPHA);
                case LOWER_LATIN:
                    return new CSSPrimitiveValue(CSS_VAL_LOWER_LATIN);
                case UPPER_ALPHA:
                    return new CSSPrimitiveValue(CSS_VAL_UPPER_ALPHA);
                case UPPER_LATIN:
                    return new CSSPrimitiveValue(CSS_VAL_UPPER_LATIN);
                case HEBREW:
                    return new CSSPrimitiveValue(CSS_VAL_HEBREW);
                case ARMENIAN:
                    return new CSSPrimitiveValue(CSS_VAL_ARMENIAN);
                case GEORGIAN:
                    return new CSSPrimitiveValue(CSS_VAL_GEORGIAN);
                case CJK_IDEOGRAPHIC:
                    return new CSSPrimitiveValue(CSS_VAL_CJK_IDEOGRAPHIC);
                case HIRAGANA:
                    return new CSSPrimitiveValue(CSS_VAL_HIRAGANA);
                case KATAKANA:
                    return new CSSPrimitiveValue(CSS_VAL_KATAKANA);
                case HIRAGANA_IROHA:
                    return new CSSPrimitiveValue(CSS_VAL_HIRAGANA_IROHA);
                case KATAKANA_IROHA:
                    return new CSSPrimitiveValue(CSS_VAL_KATAKANA_IROHA);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_MARGIN_TOP:
            if (renderer)
                // FIXME: Supposed to return the percentage if percentage was specified.
                return new CSSPrimitiveValue(renderer->marginTop(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->marginTop());
        case CSS_PROP_MARGIN_RIGHT:
            if (renderer)
                // FIXME: Supposed to return the percentage if percentage was specified.
                return new CSSPrimitiveValue(renderer->marginRight(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->marginRight());
        case CSS_PROP_MARGIN_BOTTOM:
            if (renderer)
                // FIXME: Supposed to return the percentage if percentage was specified.
                return new CSSPrimitiveValue(renderer->marginBottom(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->marginBottom());
        case CSS_PROP_MARGIN_LEFT:
            if (renderer)
                // FIXME: Supposed to return the percentage if percentage was specified.
                return new CSSPrimitiveValue(renderer->marginLeft(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->marginLeft());
        case CSS_PROP__WEBKIT_MARQUEE_DIRECTION:
            switch (style->marqueeDirection()) {
                case MFORWARD:
                    return new CSSPrimitiveValue(CSS_VAL_FORWARDS);
                case MBACKWARD:
                    return new CSSPrimitiveValue(CSS_VAL_BACKWARDS);
                case MAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case MUP:
                    return new CSSPrimitiveValue(CSS_VAL_UP);
                case MDOWN:
                    return new CSSPrimitiveValue(CSS_VAL_DOWN);
                case MLEFT:
                    return new CSSPrimitiveValue(CSS_VAL_LEFT);
                case MRIGHT:
                    return new CSSPrimitiveValue(CSS_VAL_RIGHT);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_MARQUEE_INCREMENT:
            return valueForLength(style->marqueeIncrement());
        case CSS_PROP__WEBKIT_MARQUEE_REPETITION:
            if (style->marqueeLoopCount() < 0)
                return new CSSPrimitiveValue(CSS_VAL_INFINITE);
            return new CSSPrimitiveValue(style->marqueeLoopCount(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_MARQUEE_STYLE:
            switch (style->marqueeBehavior()) {
                case MNONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
                case MSCROLL:
                    return new CSSPrimitiveValue(CSS_VAL_SCROLL);
                case MSLIDE:
                    return new CSSPrimitiveValue(CSS_VAL_SLIDE);
                case MALTERNATE:
                    return new CSSPrimitiveValue(CSS_VAL_ALTERNATE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_USER_MODIFY:
            switch (style->userModify()) {
                case READ_ONLY:
                    return new CSSPrimitiveValue(CSS_VAL_READ_ONLY);
                case READ_WRITE:
                    return new CSSPrimitiveValue(CSS_VAL_READ_WRITE);
                case READ_WRITE_PLAINTEXT_ONLY:
                    return new CSSPrimitiveValue(CSS_VAL_READ_WRITE_PLAINTEXT_ONLY);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_MAX_HEIGHT:
            return valueForMaxLength(style->maxHeight());
        case CSS_PROP_MAX_WIDTH:
            return valueForMaxLength(style->maxWidth());
        case CSS_PROP_MIN_HEIGHT:
            return valueForLength(style->minHeight());
        case CSS_PROP_MIN_WIDTH:
            return valueForLength(style->minWidth());
        case CSS_PROP_OPACITY:
            return new CSSPrimitiveValue(style->opacity(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_ORPHANS:
            return new CSSPrimitiveValue(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_OUTLINE_COLOR:
            return currentColorOrValidColor(style, style->outlineColor());
        case CSS_PROP_OUTLINE_STYLE:
            if (style->outlineStyleIsAuto())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return valueForBorderStyle(style->outlineStyle());
        case CSS_PROP_OUTLINE_WIDTH:
            return new CSSPrimitiveValue(style->outlineWidth(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_OVERFLOW:
        case CSS_PROP_OVERFLOW_X:
        case CSS_PROP_OVERFLOW_Y: {
            EOverflow overflow;
            switch (propertyID) {
                case CSS_PROP_OVERFLOW_X:
                    overflow = style->overflowX();
                    break;
                case CSS_PROP_OVERFLOW_Y:
                    overflow = style->overflowY();
                    break;
                default:
                    overflow = max(style->overflowX(), style->overflowY());
            }
            switch (overflow) {
                case OVISIBLE:
                    return new CSSPrimitiveValue(CSS_VAL_VISIBLE);
                case OHIDDEN:
                    return new CSSPrimitiveValue(CSS_VAL_HIDDEN);
                case OSCROLL:
                    return new CSSPrimitiveValue(CSS_VAL_SCROLL);
                case OAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case OMARQUEE:
                    return new CSSPrimitiveValue(CSS_VAL__WEBKIT_MARQUEE);
                case OOVERLAY:
                    return new CSSPrimitiveValue(CSS_VAL_OVERLAY);
            }
            ASSERT_NOT_REACHED();
            return 0;
        }
        case CSS_PROP_PADDING_TOP:
            if (renderer)
                return new CSSPrimitiveValue(renderer->paddingTop(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->paddingTop());
        case CSS_PROP_PADDING_RIGHT:
            if (renderer)
                return new CSSPrimitiveValue(renderer->paddingRight(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->paddingRight());
        case CSS_PROP_PADDING_BOTTOM:
            if (renderer)
                return new CSSPrimitiveValue(renderer->paddingBottom(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->paddingBottom());
        case CSS_PROP_PADDING_LEFT:
            if (renderer)
                return new CSSPrimitiveValue(renderer->paddingLeft(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->paddingLeft());
        case CSS_PROP_PAGE_BREAK_AFTER:
            switch (style->pageBreakAfter()) {
                case PBAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case PBALWAYS:
                    return new CSSPrimitiveValue(CSS_VAL_ALWAYS);
                case PBAVOID:
                    return new CSSPrimitiveValue(CSS_VAL_AVOID);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_PAGE_BREAK_BEFORE:
            switch (style->pageBreakBefore()) {
                case PBAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case PBALWAYS:
                    return new CSSPrimitiveValue(CSS_VAL_ALWAYS);
                case PBAVOID:
                    return new CSSPrimitiveValue(CSS_VAL_AVOID);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_PAGE_BREAK_INSIDE:
            switch (style->pageBreakInside()) {
                case PBAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case PBAVOID:
                    return new CSSPrimitiveValue(CSS_VAL_AVOID);
                case PBALWAYS:
                    break; // not allowed
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_POSITION:
            switch (style->position()) {
                case StaticPosition:
                    return new CSSPrimitiveValue(CSS_VAL_STATIC);
                case RelativePosition:
                    return new CSSPrimitiveValue(CSS_VAL_RELATIVE);
                case AbsolutePosition:
                    return new CSSPrimitiveValue(CSS_VAL_ABSOLUTE);
                case FixedPosition:
                    return new CSSPrimitiveValue(CSS_VAL_FIXED);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_RIGHT:
            return getPositionOffsetValue(style, CSS_PROP_RIGHT);
        case CSS_PROP_TABLE_LAYOUT:
            switch (style->tableLayout()) {
                case TAUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case TFIXED:
                    return new CSSPrimitiveValue(CSS_VAL_FIXED);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_TEXT_ALIGN:
            return valueForTextAlign(style->textAlign());
        case CSS_PROP_TEXT_DECORATION: {
            String string;
            if (style->textDecoration() & UNDERLINE)
                string += "underline";
            if (style->textDecoration() & OVERLINE) {
                if (string.length())
                    string += " ";
                string += "overline";
            }
            if (style->textDecoration() & LINE_THROUGH) {
                if (string.length())
                    string += " ";
                string += "line-through";
            }
            if (style->textDecoration() & BLINK) {
                if (string.length())
                    string += " ";
                string += "blink";
            }
            if (!string.length())
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(string, CSSPrimitiveValue::CSS_STRING);
        }
        case CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT: {
            String string;
            if (style->textDecorationsInEffect() & UNDERLINE)
                string += "underline";
            if (style->textDecorationsInEffect() & OVERLINE) {
                if (string.length())
                    string += " ";
                string += "overline";
            }
            if (style->textDecorationsInEffect() & LINE_THROUGH) {
                if (string.length())
                    string += " ";
                string += "line-through";
            }
            if (style->textDecorationsInEffect() & BLINK) {
                if (string.length())
                    string += " ";
                string += "blink";
            }
            if (!string.length())
                return new CSSPrimitiveValue(CSS_VAL_NONE);
            return new CSSPrimitiveValue(string, CSSPrimitiveValue::CSS_STRING);
        }
        case CSS_PROP__WEBKIT_TEXT_FILL_COLOR:
            return currentColorOrValidColor(style, style->textFillColor());
        case CSS_PROP_TEXT_INDENT:
            return valueForLength(style->textIndent());
        case CSS_PROP_TEXT_SHADOW:
            return valueForShadow(style->textShadow());
        case CSS_PROP__WEBKIT_TEXT_SECURITY:
            switch (style->textSecurity()) {
                case TSNONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
                case TSDISC:
                    return new CSSPrimitiveValue(CSS_VAL_DISC);
                case TSCIRCLE:
                    return new CSSPrimitiveValue(CSS_VAL_CIRCLE);
                case TSSQUARE:
                    return new CSSPrimitiveValue(CSS_VAL_SQUARE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_TEXT_SIZE_ADJUST:
            if (style->textSizeAdjust())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return new CSSPrimitiveValue(CSS_VAL_NONE);
        case CSS_PROP__WEBKIT_TEXT_STROKE_COLOR:
            return currentColorOrValidColor(style, style->textStrokeColor());
        case CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH:
            return new CSSPrimitiveValue(style->textStrokeWidth(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_TEXT_TRANSFORM:
            switch (style->textTransform()) {
                case CAPITALIZE:
                    return new CSSPrimitiveValue(CSS_VAL_CAPITALIZE);
                case UPPERCASE:
                    return new CSSPrimitiveValue(CSS_VAL_UPPERCASE);
                case LOWERCASE:
                    return new CSSPrimitiveValue(CSS_VAL_LOWERCASE);
                case TTNONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_TOP:
            return getPositionOffsetValue(style, CSS_PROP_TOP);
        case CSS_PROP_UNICODE_BIDI:
            switch (style->unicodeBidi()) {
                case UBNormal:
                    return new CSSPrimitiveValue(CSS_VAL_NORMAL);
                case Embed:
                    return new CSSPrimitiveValue(CSS_VAL_EMBED);
                case Override:
                    return new CSSPrimitiveValue(CSS_VAL_BIDI_OVERRIDE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_VERTICAL_ALIGN:
            switch (style->verticalAlign()) {
                case BASELINE:
                    return new CSSPrimitiveValue(CSS_VAL_BASELINE);
                case MIDDLE:
                    return new CSSPrimitiveValue(CSS_VAL_MIDDLE);
                case SUB:
                    return new CSSPrimitiveValue(CSS_VAL_SUB);
                case SUPER:
                    return new CSSPrimitiveValue(CSS_VAL_SUPER);
                case TEXT_TOP:
                    return new CSSPrimitiveValue(CSS_VAL_TEXT_TOP);
                case TEXT_BOTTOM:
                    return new CSSPrimitiveValue(CSS_VAL_TEXT_BOTTOM);
                case TOP:
                    return new CSSPrimitiveValue(CSS_VAL_TOP);
                case BOTTOM:
                    return new CSSPrimitiveValue(CSS_VAL_BOTTOM);
                case BASELINE_MIDDLE:
                    return new CSSPrimitiveValue(CSS_VAL__WEBKIT_BASELINE_MIDDLE);
                case LENGTH:
                    return valueForLength(style->verticalAlignLength());
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_VISIBILITY:
            switch (style->visibility()) {
                case VISIBLE:
                    return new CSSPrimitiveValue(CSS_VAL_VISIBLE);
                case HIDDEN:
                    return new CSSPrimitiveValue(CSS_VAL_HIDDEN);
                case COLLAPSE:
                    return new CSSPrimitiveValue(CSS_VAL_COLLAPSE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_WHITE_SPACE:
            switch (style->whiteSpace()) {
                case NORMAL:
                    return new CSSPrimitiveValue(CSS_VAL_NORMAL);
                case PRE:
                    return new CSSPrimitiveValue(CSS_VAL_PRE);
                case PRE_WRAP:
                    return new CSSPrimitiveValue(CSS_VAL_PRE_WRAP);
                case PRE_LINE:
                    return new CSSPrimitiveValue(CSS_VAL_PRE_LINE);
                case NOWRAP:
                    return new CSSPrimitiveValue(CSS_VAL_NOWRAP);
                case KHTML_NOWRAP:
                    return new CSSPrimitiveValue(CSS_VAL__WEBKIT_NOWRAP);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_WIDOWS:
            return new CSSPrimitiveValue(style->widows(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP_WIDTH:
            if (renderer)
                return new CSSPrimitiveValue(sizingBox(renderer).width(), CSSPrimitiveValue::CSS_PX);
            return valueForLength(style->width());
        case CSS_PROP_WORD_BREAK:
            switch (style->wordBreak()) {
                case NormalWordBreak:
                    return new CSSPrimitiveValue(CSS_VAL_NORMAL);
                case BreakAllWordBreak:
                    return new CSSPrimitiveValue(CSS_VAL_BREAK_ALL);
                case BreakWordBreak:
                    return new CSSPrimitiveValue(CSS_VAL_BREAK_WORD);
            }
        case CSS_PROP_WORD_SPACING:
            return new CSSPrimitiveValue(style->wordSpacing(), CSSPrimitiveValue::CSS_PX);
        case CSS_PROP_WORD_WRAP:
            switch (style->wordWrap()) {
                case NormalWordWrap:
                    return new CSSPrimitiveValue(CSS_VAL_NORMAL);
                case BreakWordWrap:
                    return new CSSPrimitiveValue(CSS_VAL_BREAK_WORD);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_LINE_BREAK:
            switch (style->khtmlLineBreak()) {
                case LBNORMAL:
                    return new CSSPrimitiveValue(CSS_VAL_NORMAL);
                case AFTER_WHITE_SPACE:
                    return new CSSPrimitiveValue(CSS_VAL_AFTER_WHITE_SPACE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_NBSP_MODE:
            switch (style->nbspMode()) {
                case NBNORMAL:
                    return new CSSPrimitiveValue(CSS_VAL_NORMAL);
                case SPACE:
                    return new CSSPrimitiveValue(CSS_VAL_SPACE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP__WEBKIT_MATCH_NEAREST_MAIL_BLOCKQUOTE_COLOR:
            switch (style->matchNearestMailBlockquoteColor()) {
                case BCNORMAL:
                    return new CSSPrimitiveValue(CSS_VAL_NORMAL);
                case MATCH:
                    return new CSSPrimitiveValue(CSS_VAL_MATCH);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_RESIZE:
            switch (style->resize()) {
                case RESIZE_BOTH:
                    return new CSSPrimitiveValue(CSS_VAL_BOTH);
                case RESIZE_HORIZONTAL:
                    return new CSSPrimitiveValue(CSS_VAL_HORIZONTAL);
                case RESIZE_VERTICAL:
                    return new CSSPrimitiveValue(CSS_VAL_VERTICAL);
                case RESIZE_NONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
            }
            ASSERT_NOT_REACHED();
            return 0;
        case CSS_PROP_Z_INDEX:
            if (style->hasAutoZIndex())
                return new CSSPrimitiveValue(CSS_VAL_AUTO);
            return new CSSPrimitiveValue(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);
        case CSS_PROP__WEBKIT_BOX_SIZING:
            if (style->boxSizing() == CONTENT_BOX)
                return new CSSPrimitiveValue(CSS_VAL_CONTENT_BOX);
            return new CSSPrimitiveValue(CSS_VAL_BORDER_BOX);
        case CSS_PROP__WEBKIT_DASHBOARD_REGION:
        {
            const Vector<StyleDashboardRegion>& regions = style->dashboardRegions();
            unsigned count = regions.size();
            if (count == 1 && regions[0].type == StyleDashboardRegion::None)
                return new CSSPrimitiveValue(CSS_VAL_NONE);

            RefPtr<DashboardRegion> firstRegion;
            DashboardRegion* previousRegion = 0;
            for (unsigned i = 0; i < count; i++) {
                RefPtr<DashboardRegion> region = new DashboardRegion;
                StyleDashboardRegion styleRegion = regions[i];

                region->m_label = styleRegion.label;
                LengthBox offset = styleRegion.offset;
                region->setTop(new CSSPrimitiveValue(offset.top.value(), CSSPrimitiveValue::CSS_PX));
                region->setRight(new CSSPrimitiveValue(offset.right.value(), CSSPrimitiveValue::CSS_PX));
                region->setBottom(new CSSPrimitiveValue(offset.bottom.value(), CSSPrimitiveValue::CSS_PX));
                region->setLeft(new CSSPrimitiveValue(offset.left.value(), CSSPrimitiveValue::CSS_PX));
                region->m_isRectangle = (styleRegion.type == StyleDashboardRegion::Rectangle);
                region->m_isCircle = (styleRegion.type == StyleDashboardRegion::Circle);

                if (previousRegion)
                    previousRegion->m_next = region;
                else
                    firstRegion = region;
                previousRegion = region.get();
            }
            return new CSSPrimitiveValue(firstRegion.release());
        }
        case CSS_PROP__WEBKIT_APPEARANCE:
            return valueForAppearance(style->appearance());
        case CSS_PROP__WEBKIT_FONT_SIZE_DELTA:
            // Not a real style property -- used by the editing engine -- so has no computed value.
            break;
        case CSS_PROP__WEBKIT_MARGIN_BOTTOM_COLLAPSE:
            return valueForMarginCollapse(style->marginBottomCollapse());
        case CSS_PROP__WEBKIT_MARGIN_TOP_COLLAPSE:
            return valueForMarginCollapse(style->marginTopCollapse());
        case CSS_PROP__WEBKIT_RTL_ORDERING:
            if (style->visuallyOrdered())
                return new CSSPrimitiveValue(CSS_VAL_VISUAL);
            return new CSSPrimitiveValue(CSS_VAL_LOGICAL);
        case CSS_PROP__WEBKIT_USER_DRAG:
            switch (style->userDrag()) {
                case DRAG_AUTO:
                    return new CSSPrimitiveValue(CSS_VAL_AUTO);
                case DRAG_NONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
                case DRAG_ELEMENT:
                    return new CSSPrimitiveValue(CSS_VAL_ELEMENT);
            }
            break;
        case CSS_PROP__WEBKIT_USER_SELECT:
            switch (style->userSelect()) {
                case SELECT_NONE:
                    return new CSSPrimitiveValue(CSS_VAL_NONE);
                case SELECT_TEXT:
                    return new CSSPrimitiveValue(CSS_VAL_TEXT);
            }
            break;
        case CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS:
            return getBorderRadiusCornerValue(style->borderBottomLeftRadius());
        case CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS:
            return getBorderRadiusCornerValue(style->borderBottomRightRadius());
        case CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS:
            return getBorderRadiusCornerValue(style->borderTopLeftRadius());
        case CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS:
            return getBorderRadiusCornerValue(style->borderTopRightRadius());
        case CSS_PROP_BACKGROUND:
        case CSS_PROP_BORDER:
        case CSS_PROP_BORDER_BOTTOM:
        case CSS_PROP_BORDER_COLOR:
        case CSS_PROP_BORDER_LEFT:
        case CSS_PROP_BORDER_RIGHT:
        case CSS_PROP_BORDER_STYLE:
        case CSS_PROP_BORDER_TOP:
        case CSS_PROP_BORDER_WIDTH:
        case CSS_PROP_CLIP:
        case CSS_PROP_CONTENT:
        case CSS_PROP_COUNTER_INCREMENT:
        case CSS_PROP_COUNTER_RESET:
        case CSS_PROP_FONT:
        case CSS_PROP_FONT_STRETCH:
        case CSS_PROP_LIST_STYLE:
        case CSS_PROP_MARGIN:
        case CSS_PROP_OUTLINE:
        case CSS_PROP_OUTLINE_OFFSET:
        case CSS_PROP_PADDING:
        case CSS_PROP_PAGE:
        case CSS_PROP_QUOTES:
        case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR:
        case CSS_PROP_SCROLLBAR_ARROW_COLOR:
        case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR:
        case CSS_PROP_SCROLLBAR_FACE_COLOR:
        case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR:
        case CSS_PROP_SCROLLBAR_SHADOW_COLOR:
        case CSS_PROP_SCROLLBAR_TRACK_COLOR:
        case CSS_PROP_SIZE:
        case CSS_PROP_TEXT_LINE_THROUGH:
        case CSS_PROP_TEXT_LINE_THROUGH_COLOR:
        case CSS_PROP_TEXT_LINE_THROUGH_MODE:
        case CSS_PROP_TEXT_LINE_THROUGH_STYLE:
        case CSS_PROP_TEXT_LINE_THROUGH_WIDTH:
        case CSS_PROP_TEXT_OVERFLOW:
        case CSS_PROP_TEXT_OVERLINE:
        case CSS_PROP_TEXT_OVERLINE_COLOR:
        case CSS_PROP_TEXT_OVERLINE_MODE:
        case CSS_PROP_TEXT_OVERLINE_STYLE:
        case CSS_PROP_TEXT_OVERLINE_WIDTH:
        case CSS_PROP_TEXT_UNDERLINE:
        case CSS_PROP_TEXT_UNDERLINE_COLOR:
        case CSS_PROP_TEXT_UNDERLINE_MODE:
        case CSS_PROP_TEXT_UNDERLINE_STYLE:
        case CSS_PROP_TEXT_UNDERLINE_WIDTH:
        case CSS_PROP__WEBKIT_BORDER_IMAGE:
        case CSS_PROP__WEBKIT_BORDER_RADIUS:
        case CSS_PROP__WEBKIT_COLUMNS:
        case CSS_PROP__WEBKIT_COLUMN_RULE:
        case CSS_PROP__WEBKIT_MARGIN_COLLAPSE:
        case CSS_PROP__WEBKIT_MARGIN_START:
        case CSS_PROP__WEBKIT_MARQUEE:
        case CSS_PROP__WEBKIT_MARQUEE_SPEED:
        case CSS_PROP__WEBKIT_PADDING_START:
        case CSS_PROP__WEBKIT_TEXT_STROKE:
            // FIXME: The above are unimplemented.
            break;
    }

    LOG_ERROR("unimplemented propertyID: %d", propertyID);
    return 0;
}

String CSSComputedStyleDeclaration::getPropertyValue(int propertyID) const
{
    RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);
    if (value)
        return value->cssText();
    return "";
}

bool CSSComputedStyleDeclaration::getPropertyPriority(int /*propertyID*/) const
{
    // All computed styles have a priority of false (not "important").
    return false;
}

String CSSComputedStyleDeclaration::removeProperty(int /*propertyID*/, ExceptionCode& ec)
{
    ec = NO_MODIFICATION_ALLOWED_ERR;
    return String();
}

void CSSComputedStyleDeclaration::setProperty(int /*propertyID*/, const String& /*value*/, bool /*important*/, ExceptionCode& ec)
{
    ec = NO_MODIFICATION_ALLOWED_ERR;
}

unsigned CSSComputedStyleDeclaration::length() const
{
    Node* node = m_node.get();
    if (!node)
        return 0;

    RenderStyle* style = node->computedStyle();
    if (!style)
        return 0;

    return numComputedProperties;
}

String CSSComputedStyleDeclaration::item(unsigned i) const
{
    if (i >= length())
        return String();

    return getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));
}

// This is the list of properties we want to copy in the copyInheritableProperties() function.
// It is the intersection of the list of inherited CSS properties and the
// properties for which we have a computed implementation in this file.
const int inheritableProperties[] = {
    CSS_PROP_BORDER_COLLAPSE,
    CSS_PROP_COLOR,
    CSS_PROP_FONT_FAMILY,
    CSS_PROP_FONT_SIZE,
    CSS_PROP_FONT_STYLE,
    CSS_PROP_FONT_VARIANT,
    CSS_PROP_FONT_WEIGHT,
    CSS_PROP_LETTER_SPACING,
    CSS_PROP_LINE_HEIGHT,
    CSS_PROP_ORPHANS,
    CSS_PROP_TEXT_ALIGN,
    CSS_PROP_TEXT_INDENT,
    CSS_PROP_TEXT_TRANSFORM,
    CSS_PROP_WHITE_SPACE,
    CSS_PROP_WIDOWS,
    CSS_PROP_WORD_SPACING,
    CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING,
    CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING,
    CSS_PROP__WEBKIT_TEXT_DECORATIONS_IN_EFFECT,
    CSS_PROP__WEBKIT_TEXT_FILL_COLOR,
    CSS_PROP__WEBKIT_TEXT_SIZE_ADJUST,
    CSS_PROP__WEBKIT_TEXT_STROKE_COLOR,
    CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH,
};

const unsigned numInheritableProperties = sizeof(inheritableProperties) / sizeof(inheritableProperties[0]);

void CSSComputedStyleDeclaration::removeComputedInheritablePropertiesFrom(CSSMutableStyleDeclaration* declaration)
{
    declaration->removePropertiesInSet(inheritableProperties, numInheritableProperties);
}

PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::copyInheritableProperties() const
{
    RefPtr<CSSMutableStyleDeclaration> style = copyPropertiesInSet(inheritableProperties, numInheritableProperties);
    if (style && m_node && m_node->computedStyle()) {
        // If a node's text fill color is invalid, then its children use 
        // their font-color as their text fill color (they don't
        // inherit it).  Likewise for stroke color.
        ExceptionCode ec = 0;
        if (!m_node->computedStyle()->textFillColor().isValid())
            style->removeProperty(CSS_PROP__WEBKIT_TEXT_FILL_COLOR, ec);
        if (!m_node->computedStyle()->textStrokeColor().isValid())
            style->removeProperty(CSS_PROP__WEBKIT_TEXT_STROKE_COLOR, ec);
        ASSERT(ec == 0);
    }
    return style.release();
}

PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::copy() const
{
    return copyPropertiesInSet(computedProperties, numComputedProperties);
}

PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::makeMutable()
{
    return copy();
}

PassRefPtr<CSSComputedStyleDeclaration> computedStyle(Node* node)
{
    return new CSSComputedStyleDeclaration(node);
}

} // namespace WebCore