WebCore/css/CSSComputedStyleDeclaration.cpp

   1 /*
   2  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
   3  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   4  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
   5  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301  USA
  21  */
  22
  23 #include "config.h"
  24 #include "CSSComputedStyleDeclaration.h"
  25
  26 #include "AnimationController.h"
  27 #include "CSSBorderImageValue.h"
  28 #include "CSSMutableStyleDeclaration.h"
  29 #include "CSSPrimitiveValue.h"
  30 #include "CSSPrimitiveValueMappings.h"
  31 #include "CSSProperty.h"
  32 #include "CSSPropertyNames.h"
  33 #include "CSSReflectValue.h"
  34 #include "CSSSelector.h"
  35 #include "CSSTimingFunctionValue.h"
  36 #include "CSSValueList.h"
  37 #include "Document.h"
  38 #include "ExceptionCode.h"
  39 #include "Rect.h"
  40 #include "RenderBox.h"
  41 #include "RenderLayer.h"
  42 #include "ShadowValue.h"
  43 #ifdef ANDROID_LAYOUT
  44 #include "Frame.h"
  45 #include "Settings.h"
  46 #endif
  47 #include "WebKitCSSTransformValue.h"
  48
  49 #if ENABLE(DASHBOARD_SUPPORT)
  50 #include "DashboardRegion.h"
  51 #endif
  52
  53 namespace WebCore {
  54
  55 // List of all properties we know how to compute, omitting shorthands.
  56 static const int computedProperties[] = {
  57     CSSPropertyBackgroundAttachment,
  58     CSSPropertyBackgroundClip,
  59     CSSPropertyBackgroundColor,
  60     CSSPropertyBackgroundImage,
  61     CSSPropertyBackgroundOrigin,
  62     CSSPropertyBackgroundPosition, // more-specific background-position-x/y are non-standard
  63     CSSPropertyBackgroundRepeat,
  64     CSSPropertyBackgroundSize,
  65     CSSPropertyBorderBottomColor,
  66     CSSPropertyBorderBottomLeftRadius,
  67     CSSPropertyBorderBottomRightRadius,
  68     CSSPropertyBorderBottomStyle,
  69     CSSPropertyBorderBottomWidth,
  70     CSSPropertyBorderCollapse,
  71     CSSPropertyBorderLeftColor,
  72     CSSPropertyBorderLeftStyle,
  73     CSSPropertyBorderLeftWidth,
  74     CSSPropertyBorderRightColor,
  75     CSSPropertyBorderRightStyle,
  76     CSSPropertyBorderRightWidth,
  77     CSSPropertyBorderTopColor,
  78     CSSPropertyBorderTopLeftRadius,
  79     CSSPropertyBorderTopRightRadius,
  80     CSSPropertyBorderTopStyle,
  81     CSSPropertyBorderTopWidth,
  82     CSSPropertyBottom,
  83     CSSPropertyCaptionSide,
  84     CSSPropertyClear,
  85     CSSPropertyClip,
  86     CSSPropertyColor,
  87     CSSPropertyCursor,
  88     CSSPropertyDirection,
  89     CSSPropertyDisplay,
  90     CSSPropertyEmptyCells,
  91     CSSPropertyFloat,
  92     CSSPropertyFontFamily,
  93     CSSPropertyFontSize,
  94     CSSPropertyFontStyle,
  95     CSSPropertyFontVariant,
  96     CSSPropertyFontWeight,
  97     CSSPropertyHeight,
  98     CSSPropertyLeft,
  99     CSSPropertyLetterSpacing,
 100     CSSPropertyLineHeight,
 101     CSSPropertyListStyleImage,
 102     CSSPropertyListStylePosition,
 103     CSSPropertyListStyleType,
 104     CSSPropertyMarginBottom,
 105     CSSPropertyMarginLeft,
 106     CSSPropertyMarginRight,
 107     CSSPropertyMarginTop,
 108     CSSPropertyMaxHeight,
 109     CSSPropertyMaxWidth,
 110     CSSPropertyMinHeight,
 111     CSSPropertyMinWidth,
 112     CSSPropertyOpacity,
 113     CSSPropertyOrphans,
 114     CSSPropertyOutlineColor,
 115     CSSPropertyOutlineStyle,
 116     CSSPropertyOutlineWidth,
 117     CSSPropertyOverflowX,
 118     CSSPropertyOverflowY,
 119     CSSPropertyPaddingBottom,
 120     CSSPropertyPaddingLeft,
 121     CSSPropertyPaddingRight,
 122     CSSPropertyPaddingTop,
 123     CSSPropertyPageBreakAfter,
 124     CSSPropertyPageBreakBefore,
 125     CSSPropertyPageBreakInside,
 126     CSSPropertyPointerEvents,
 127     CSSPropertyPosition,
 128     CSSPropertyResize,
 129     CSSPropertyRight,
 130     CSSPropertyTableLayout,
 131     CSSPropertyTextAlign,
 132     CSSPropertyTextDecoration,
 133     CSSPropertyTextIndent,
 134     CSSPropertyTextRendering,
 135     CSSPropertyTextShadow,
 136     CSSPropertyTextOverflow,
 137     CSSPropertyTextTransform,
 138     CSSPropertyTop,
 139     CSSPropertyUnicodeBidi,
 140     CSSPropertyVerticalAlign,
 141     CSSPropertyVisibility,
 142     CSSPropertyWhiteSpace,
 143     CSSPropertyWidows,
 144     CSSPropertyWidth,
 145     CSSPropertyWordBreak,
 146     CSSPropertyWordSpacing,
 147     CSSPropertyWordWrap,
 148     CSSPropertyZIndex,
 149     CSSPropertyZoom,
 150
 151     CSSPropertyWebkitAnimationDelay,
 152     CSSPropertyWebkitAnimationDirection,
 153     CSSPropertyWebkitAnimationDuration,
 154     CSSPropertyWebkitAnimationFillMode,
 155     CSSPropertyWebkitAnimationIterationCount,
 156     CSSPropertyWebkitAnimationName,
 157     CSSPropertyWebkitAnimationPlayState,
 158     CSSPropertyWebkitAnimationTimingFunction,
 159     CSSPropertyWebkitAppearance,
 160     CSSPropertyWebkitBackfaceVisibility,
 161     CSSPropertyWebkitBackgroundClip,
 162     CSSPropertyWebkitBackgroundComposite,
 163     CSSPropertyWebkitBackgroundOrigin,
 164     CSSPropertyWebkitBackgroundSize,
 165     CSSPropertyWebkitBorderFit,
 166     CSSPropertyWebkitBorderHorizontalSpacing,
 167     CSSPropertyWebkitBorderImage,
 168     CSSPropertyWebkitBorderVerticalSpacing,
 169     CSSPropertyWebkitBoxAlign,
 170     CSSPropertyWebkitBoxDirection,
 171     CSSPropertyWebkitBoxFlex,
 172     CSSPropertyWebkitBoxFlexGroup,
 173     CSSPropertyWebkitBoxLines,
 174     CSSPropertyWebkitBoxOrdinalGroup,
 175     CSSPropertyWebkitBoxOrient,
 176     CSSPropertyWebkitBoxPack,
 177     CSSPropertyWebkitBoxReflect,
 178     CSSPropertyWebkitBoxShadow,
 179     CSSPropertyWebkitBoxSizing,
 180     CSSPropertyWebkitColorCorrection,
 181     CSSPropertyWebkitColumnBreakAfter,
 182     CSSPropertyWebkitColumnBreakBefore,
 183     CSSPropertyWebkitColumnBreakInside,
 184     CSSPropertyWebkitColumnCount,
 185     CSSPropertyWebkitColumnGap,
 186     CSSPropertyWebkitColumnRuleColor,
 187     CSSPropertyWebkitColumnRuleStyle,
 188     CSSPropertyWebkitColumnRuleWidth,
 189     CSSPropertyWebkitColumnSpan,
 190     CSSPropertyWebkitColumnWidth,
 191 #if ENABLE(DASHBOARD_SUPPORT)
 192     CSSPropertyWebkitDashboardRegion,
 193 #endif
 194     CSSPropertyWebkitFontSmoothing,
 195     CSSPropertyWebkitHighlight,
 196     CSSPropertyWebkitLineBreak,
 197     CSSPropertyWebkitLineClamp,
 198     CSSPropertyWebkitMarginBottomCollapse,
 199     CSSPropertyWebkitMarginTopCollapse,
 200     CSSPropertyWebkitMarqueeDirection,
 201     CSSPropertyWebkitMarqueeIncrement,
 202     CSSPropertyWebkitMarqueeRepetition,
 203     CSSPropertyWebkitMarqueeStyle,
 204     CSSPropertyWebkitMaskAttachment,
 205     CSSPropertyWebkitMaskBoxImage,
 206     CSSPropertyWebkitMaskClip,
 207     CSSPropertyWebkitMaskComposite,
 208     CSSPropertyWebkitMaskImage,
 209     CSSPropertyWebkitMaskOrigin,
 210     CSSPropertyWebkitMaskPosition,
 211     CSSPropertyWebkitMaskRepeat,
 212     CSSPropertyWebkitMaskSize,
 213     CSSPropertyWebkitNbspMode,
 214     CSSPropertyWebkitPerspective,
 215     CSSPropertyWebkitPerspectiveOrigin,
 216     CSSPropertyWebkitRtlOrdering,
 217     CSSPropertyWebkitTextDecorationsInEffect,
 218     CSSPropertyWebkitTextFillColor,
 219     CSSPropertyWebkitTextSecurity,
 220     CSSPropertyWebkitTextStrokeColor,
 221     CSSPropertyWebkitTextStrokeWidth,
 222     CSSPropertyWebkitTransform,
 223     CSSPropertyWebkitTransformOrigin,
 224     CSSPropertyWebkitTransformStyle,
 225     CSSPropertyWebkitTransitionDelay,
 226     CSSPropertyWebkitTransitionDuration,
 227     CSSPropertyWebkitTransitionProperty,
 228     CSSPropertyWebkitTransitionTimingFunction,
 229     CSSPropertyWebkitUserDrag,
 230     CSSPropertyWebkitUserModify,
 231     CSSPropertyWebkitUserSelect
 232
 233 #if ENABLE(SVG)
 234     ,
 235     CSSPropertyClipPath,
 236     CSSPropertyClipRule,
 237     CSSPropertyMask,
 238     CSSPropertyFilter,
 239     CSSPropertyFloodColor,
 240     CSSPropertyFloodOpacity,
 241     CSSPropertyLightingColor,
 242     CSSPropertyStopColor,
 243     CSSPropertyStopOpacity,
 244     CSSPropertyColorInterpolation,
 245     CSSPropertyColorInterpolationFilters,
 246     CSSPropertyColorRendering,
 247     CSSPropertyFill,
 248     CSSPropertyFillOpacity,
 249     CSSPropertyFillRule,
 250     CSSPropertyImageRendering,
 251     CSSPropertyMarkerEnd,
 252     CSSPropertyMarkerMid,
 253     CSSPropertyMarkerStart,
 254     CSSPropertyShapeRendering,
 255     CSSPropertyStroke,
 256     CSSPropertyStrokeDasharray,
 257     CSSPropertyStrokeDashoffset,
 258     CSSPropertyStrokeLinecap,
 259     CSSPropertyStrokeLinejoin,
 260     CSSPropertyStrokeMiterlimit,
 261     CSSPropertyStrokeOpacity,
 262     CSSPropertyStrokeWidth,
 263     CSSPropertyAlignmentBaseline,
 264     CSSPropertyBaselineShift,
 265     CSSPropertyDominantBaseline,
 266     CSSPropertyKerning,
 267     CSSPropertyTextAnchor,
 268     CSSPropertyWritingMode,
 269     CSSPropertyGlyphOrientationHorizontal,
 270     CSSPropertyGlyphOrientationVertical,
 271     CSSPropertyWebkitSvgShadow,
 272     CSSPropertyVectorEffect
 273 #endif
 274 #ifdef ANDROID_CSS_TAP_HIGHLIGHT_COLOR
 275     ,
 276     CSSPropertyWebkitTapHighlightColor
 277 #endif
 278 };
 279
 280 const unsigned numComputedProperties = sizeof(computedProperties) / sizeof(computedProperties[0]);
 281
 282 static int valueForRepeatRule(int rule)
 283 {
 284     switch (rule) {
 285         case RepeatImageRule:
 286             return CSSValueRepeat;
 287         case RoundImageRule:
 288             return CSSValueRound;
 289         default:
 290             return CSSValueStretch;
 291     }
 292 }
 293
 294 static PassRefPtr<CSSValue> valueForNinePieceImage(const NinePieceImage& image)
 295 {
 296     if (!image.hasImage())
 297         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 298
 299     // Image first.
 300     RefPtr<CSSValue> imageValue;
 301     if (image.image())
 302         imageValue = image.image()->cssValue();
 303
 304     // Create the slices.
 305     RefPtr<CSSPrimitiveValue> top;
 306     if (image.slices().top().isPercent())
 307         top = CSSPrimitiveValue::create(image.slices().top().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
 308     else
 309         top = CSSPrimitiveValue::create(image.slices().top().value(), CSSPrimitiveValue::CSS_NUMBER);
 310
 311     RefPtr<CSSPrimitiveValue> right;
 312     if (image.slices().right().isPercent())
 313         right = CSSPrimitiveValue::create(image.slices().right().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
 314     else
 315         right = CSSPrimitiveValue::create(image.slices().right().value(), CSSPrimitiveValue::CSS_NUMBER);
 316
 317     RefPtr<CSSPrimitiveValue> bottom;
 318     if (image.slices().bottom().isPercent())
 319         bottom = CSSPrimitiveValue::create(image.slices().bottom().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
 320     else
 321         bottom = CSSPrimitiveValue::create(image.slices().bottom().value(), CSSPrimitiveValue::CSS_NUMBER);
 322
 323     RefPtr<CSSPrimitiveValue> left;
 324     if (image.slices().left().isPercent())
 325         left = CSSPrimitiveValue::create(image.slices().left().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
 326     else
 327         left = CSSPrimitiveValue::create(image.slices().left().value(), CSSPrimitiveValue::CSS_NUMBER);
 328
 329     RefPtr<Rect> rect = Rect::create();
 330     rect->setTop(top);
 331     rect->setRight(right);
 332     rect->setBottom(bottom);
 333     rect->setLeft(left);
 334
 335     return CSSBorderImageValue::create(imageValue, rect, valueForRepeatRule(image.horizontalRule()), valueForRepeatRule(image.verticalRule()));
 336 }
 337
 338 static PassRefPtr<CSSValue> valueForReflection(const StyleReflection* reflection)
 339 {
 340     if (!reflection)
 341         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 342
 343     RefPtr<CSSPrimitiveValue> offset;
 344     if (reflection->offset().isPercent())
 345         offset = CSSPrimitiveValue::create(reflection->offset().percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
 346     else
 347         offset = CSSPrimitiveValue::create(reflection->offset().value(), CSSPrimitiveValue::CSS_PX);
 348
 349     return CSSReflectValue::create(reflection->direction(), offset.release(), valueForNinePieceImage(reflection->mask()));
 350 }
 351
 352 static PassRefPtr<CSSValue> getPositionOffsetValue(RenderStyle* style, int propertyID)
 353 {
 354     if (!style)
 355         return 0;
 356
 357     Length l;
 358     switch (propertyID) {
 359         case CSSPropertyLeft:
 360             l = style->left();
 361             break;
 362         case CSSPropertyRight:
 363             l = style->right();
 364             break;
 365         case CSSPropertyTop:
 366             l = style->top();
 367             break;
 368         case CSSPropertyBottom:
 369             l = style->bottom();
 370             break;
 371         default:
 372             return 0;
 373     }
 374
 375     if (style->position() == AbsolutePosition || style->position() == FixedPosition)
 376         return CSSPrimitiveValue::create(l);
 377
 378     if (style->position() == RelativePosition)
 379         // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
 380         // In other words if left is auto and right is not auto, then left's computed value is negative right().
 381         // So we should get the opposite length unit and see if it is auto.
 382         return CSSPrimitiveValue::create(l);
 383
 384     return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
 385 }
 386
 387 PassRefPtr<CSSPrimitiveValue> CSSComputedStyleDeclaration::currentColorOrValidColor(RenderStyle* style, const Color& color) const
 388 {
 389     // This function does NOT look at visited information, so that computed style doesn't expose that.
 390     if (!color.isValid())
 391         return CSSPrimitiveValue::createColor(style->color().rgb());
 392     return CSSPrimitiveValue::createColor(color.rgb());
 393 }
 394
 395 static PassRefPtr<CSSValue> getBorderRadiusCornerValue(IntSize radius)
 396 {
 397     if (radius.width() == radius.height())
 398         return CSSPrimitiveValue::create(radius.width(), CSSPrimitiveValue::CSS_PX);
 399
 400     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 401     list->append(CSSPrimitiveValue::create(radius.width(), CSSPrimitiveValue::CSS_PX));
 402     list->append(CSSPrimitiveValue::create(radius.height(), CSSPrimitiveValue::CSS_PX));
 403     return list.release();
 404 }
 405
 406 static IntRect sizingBox(RenderObject* renderer)
 407 {
 408     if (!renderer->isBox())
 409         return IntRect();
 410
 411     RenderBox* box = toRenderBox(renderer);
 412     return box->style()->boxSizing() == CONTENT_BOX ? box->contentBoxRect() : box->borderBoxRect();
 413 }
 414
 415 static inline bool hasCompositedLayer(RenderObject* renderer)
 416 {
 417     return renderer && renderer->hasLayer() && toRenderBoxModelObject(renderer)->layer()->isComposited();
 418 }
 419
 420 static PassRefPtr<CSSValue> computedTransform(RenderObject* renderer, const RenderStyle* style)
 421 {
 422     if (!renderer || style->transform().operations().isEmpty())
 423         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 424
 425     IntRect box = sizingBox(renderer);
 426
 427     TransformationMatrix transform;
 428     style->applyTransform(transform, box.size(), RenderStyle::ExcludeTransformOrigin);
 429     // Note that this does not flatten to an affine transform if ENABLE(3D_RENDERING) is off, by design.
 430
 431     RefPtr<WebKitCSSTransformValue> transformVal;
 432
 433     // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
 434     if (transform.isAffine()) {
 435         transformVal = WebKitCSSTransformValue::create(WebKitCSSTransformValue::MatrixTransformOperation);
 436
 437         transformVal->append(CSSPrimitiveValue::create(transform.a(), CSSPrimitiveValue::CSS_NUMBER));
 438         transformVal->append(CSSPrimitiveValue::create(transform.b(), CSSPrimitiveValue::CSS_NUMBER));
 439         transformVal->append(CSSPrimitiveValue::create(transform.c(), CSSPrimitiveValue::CSS_NUMBER));
 440         transformVal->append(CSSPrimitiveValue::create(transform.d(), CSSPrimitiveValue::CSS_NUMBER));
 441         transformVal->append(CSSPrimitiveValue::create(transform.e(), CSSPrimitiveValue::CSS_NUMBER));
 442         transformVal->append(CSSPrimitiveValue::create(transform.f(), CSSPrimitiveValue::CSS_NUMBER));
 443     } else {
 444         transformVal = WebKitCSSTransformValue::create(WebKitCSSTransformValue::Matrix3DTransformOperation);
 445
 446         transformVal->append(CSSPrimitiveValue::create(transform.m11(), CSSPrimitiveValue::CSS_NUMBER));
 447         transformVal->append(CSSPrimitiveValue::create(transform.m12(), CSSPrimitiveValue::CSS_NUMBER));
 448         transformVal->append(CSSPrimitiveValue::create(transform.m13(), CSSPrimitiveValue::CSS_NUMBER));
 449         transformVal->append(CSSPrimitiveValue::create(transform.m14(), CSSPrimitiveValue::CSS_NUMBER));
 450
 451         transformVal->append(CSSPrimitiveValue::create(transform.m21(), CSSPrimitiveValue::CSS_NUMBER));
 452         transformVal->append(CSSPrimitiveValue::create(transform.m22(), CSSPrimitiveValue::CSS_NUMBER));
 453         transformVal->append(CSSPrimitiveValue::create(transform.m23(), CSSPrimitiveValue::CSS_NUMBER));
 454         transformVal->append(CSSPrimitiveValue::create(transform.m24(), CSSPrimitiveValue::CSS_NUMBER));
 455
 456         transformVal->append(CSSPrimitiveValue::create(transform.m31(), CSSPrimitiveValue::CSS_NUMBER));
 457         transformVal->append(CSSPrimitiveValue::create(transform.m32(), CSSPrimitiveValue::CSS_NUMBER));
 458         transformVal->append(CSSPrimitiveValue::create(transform.m33(), CSSPrimitiveValue::CSS_NUMBER));
 459         transformVal->append(CSSPrimitiveValue::create(transform.m34(), CSSPrimitiveValue::CSS_NUMBER));
 460
 461         transformVal->append(CSSPrimitiveValue::create(transform.m41(), CSSPrimitiveValue::CSS_NUMBER));
 462         transformVal->append(CSSPrimitiveValue::create(transform.m42(), CSSPrimitiveValue::CSS_NUMBER));
 463         transformVal->append(CSSPrimitiveValue::create(transform.m43(), CSSPrimitiveValue::CSS_NUMBER));
 464         transformVal->append(CSSPrimitiveValue::create(transform.m44(), CSSPrimitiveValue::CSS_NUMBER));
 465     }
 466
 467     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 468     list->append(transformVal);
 469
 470     return list.release();
 471 }
 472
 473 static PassRefPtr<CSSValue> getDelayValue(const AnimationList* animList)
 474 {
 475     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 476     if (animList) {
 477         for (size_t i = 0; i < animList->size(); ++i)
 478             list->append(CSSPrimitiveValue::create(animList->animation(i)->delay(), CSSPrimitiveValue::CSS_S));
 479     } else {
 480         // Note that initialAnimationDelay() is used for both transitions and animations
 481         list->append(CSSPrimitiveValue::create(Animation::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
 482     }
 483     return list.release();
 484 }
 485
 486 static PassRefPtr<CSSValue> getDurationValue(const AnimationList* animList)
 487 {
 488     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 489     if (animList) {
 490         for (size_t i = 0; i < animList->size(); ++i)
 491             list->append(CSSPrimitiveValue::create(animList->animation(i)->duration(), CSSPrimitiveValue::CSS_S));
 492     } else {
 493         // Note that initialAnimationDuration() is used for both transitions and animations
 494         list->append(CSSPrimitiveValue::create(Animation::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
 495     }
 496     return list.release();
 497 }
 498
 499 static PassRefPtr<CSSValue> getTimingFunctionValue(const AnimationList* animList)
 500 {
 501     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 502     if (animList) {
 503         for (size_t i = 0; i < animList->size(); ++i) {
 504             const TimingFunction& tf = animList->animation(i)->timingFunction();
 505             list->append(CSSTimingFunctionValue::create(tf.x1(), tf.y1(), tf.x2(), tf.y2()));
 506         }
 507     } else {
 508         // Note that initialAnimationTimingFunction() is used for both transitions and animations
 509         const TimingFunction& tf = Animation::initialAnimationTimingFunction();
 510         list->append(CSSTimingFunctionValue::create(tf.x1(), tf.y1(), tf.x2(), tf.y2()));
 511     }
 512     return list.release();
 513 }
 514
 515 CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n, bool allowVisitedStyle, const String& pseudoElementName)
 516     : m_node(n)
 517     , m_allowVisitedStyle(allowVisitedStyle)
 518 {
 519     unsigned nameWithoutColonsStart = pseudoElementName[0] == ':' ? (pseudoElementName[1] == ':' ? 2 : 1) : 0;
 520     m_pseudoElementSpecifier = CSSSelector::pseudoId(CSSSelector::parsePseudoType(
 521         AtomicString(pseudoElementName.substring(nameWithoutColonsStart))));
 522 }
 523
 524 CSSComputedStyleDeclaration::~CSSComputedStyleDeclaration()
 525 {
 526 }
 527
 528 String CSSComputedStyleDeclaration::cssText() const
 529 {
 530     String result("");
 531
 532     for (unsigned i = 0; i < numComputedProperties; i++) {
 533         if (i)
 534             result += " ";
 535         result += getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));
 536         result += ": ";
 537         result += getPropertyValue(computedProperties[i]);
 538         result += ";";
 539     }
 540
 541     return result;
 542 }
 543
 544 void CSSComputedStyleDeclaration::setCssText(const String&, ExceptionCode& ec)
 545 {
 546     ec = NO_MODIFICATION_ALLOWED_ERR;
 547 }
 548
 549 static int cssIdentifierForFontSizeKeyword(int keywordSize)
 550 {
 551     ASSERT_ARG(keywordSize, keywordSize);
 552     ASSERT_ARG(keywordSize, keywordSize <= 8);
 553     return CSSValueXxSmall + keywordSize - 1;
 554 }
 555
 556 PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getFontSizeCSSValuePreferringKeyword() const
 557 {
 558     Node* node = m_node.get();
 559     if (!node)
 560         return 0;
 561
 562     node->document()->updateLayoutIgnorePendingStylesheets();
 563
 564     RefPtr<RenderStyle> style = node->computedStyle(m_pseudoElementSpecifier);
 565     if (!style)
 566         return 0;
 567
 568     if (int keywordSize = style->fontDescription().keywordSize())
 569         return CSSPrimitiveValue::createIdentifier(cssIdentifierForFontSizeKeyword(keywordSize));
 570
 571     return CSSPrimitiveValue::create(style->fontDescription().computedPixelSize(), CSSPrimitiveValue::CSS_PX);
 572 }
 573
 574 PassRefPtr<CSSValue> CSSComputedStyleDeclaration::valueForShadow(const ShadowData* shadow, int id) const
 575 {
 576     if (!shadow)
 577         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 578
 579     CSSPropertyID propertyID = static_cast<CSSPropertyID>(id);
 580
 581     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 582     for (const ShadowData* s = shadow; s; s = s->next()) {
 583         RefPtr<CSSPrimitiveValue> x = CSSPrimitiveValue::create(s->x(), CSSPrimitiveValue::CSS_PX);
 584         RefPtr<CSSPrimitiveValue> y = CSSPrimitiveValue::create(s->y(), CSSPrimitiveValue::CSS_PX);
 585         RefPtr<CSSPrimitiveValue> blur = CSSPrimitiveValue::create(s->blur(), CSSPrimitiveValue::CSS_PX);
 586         RefPtr<CSSPrimitiveValue> spread = propertyID == CSSPropertyTextShadow ? 0 : CSSPrimitiveValue::create(s->spread(), CSSPrimitiveValue::CSS_PX);
 587         RefPtr<CSSPrimitiveValue> style = propertyID == CSSPropertyTextShadow || s->style() == Normal ? 0 : CSSPrimitiveValue::createIdentifier(CSSValueInset);
 588         RefPtr<CSSPrimitiveValue> color = CSSPrimitiveValue::createColor(s->color().rgb());
 589         list->prepend(ShadowValue::create(x.release(), y.release(), blur.release(), spread.release(), style.release(), color.release()));
 590     }
 591     return list.release();
 592 }
 593
 594 PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID) const
 595 {
 596     return getPropertyCSSValue(propertyID, UpdateLayout);
 597 }
 598
 599 static int identifierForFamily(const AtomicString& family)
 600 {
 601     DEFINE_STATIC_LOCAL(AtomicString, cursiveFamily, ("-webkit-cursive"));
 602     DEFINE_STATIC_LOCAL(AtomicString, fantasyFamily, ("-webkit-fantasy"));
 603     DEFINE_STATIC_LOCAL(AtomicString, monospaceFamily, ("-webkit-monospace"));
 604     DEFINE_STATIC_LOCAL(AtomicString, sansSerifFamily, ("-webkit-sans-serif"));
 605     DEFINE_STATIC_LOCAL(AtomicString, serifFamily, ("-webkit-serif"));
 606     if (family == cursiveFamily)
 607         return CSSValueCursive;
 608     if (family == fantasyFamily)
 609         return CSSValueFantasy;
 610     if (family == monospaceFamily)
 611         return CSSValueMonospace;
 612     if (family == sansSerifFamily)
 613         return CSSValueSansSerif;
 614     if (family == serifFamily)
 615         return CSSValueSerif;
 616     return 0;
 617 }
 618
 619 static PassRefPtr<CSSPrimitiveValue> valueForFamily(const AtomicString& family)
 620 {
 621     if (int familyIdentifier = identifierForFamily(family))
 622         return CSSPrimitiveValue::createIdentifier(familyIdentifier);
 623     return CSSPrimitiveValue::create(family.string(), CSSPrimitiveValue::CSS_STRING);
 624 }
 625
 626 static PassRefPtr<CSSValue> renderTextDecorationFlagsToCSSValue(int textDecoration)
 627 {
 628     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 629     if (textDecoration & UNDERLINE)
 630         list->append(CSSPrimitiveValue::createIdentifier(CSSValueUnderline));
 631     if (textDecoration & OVERLINE)
 632         list->append(CSSPrimitiveValue::createIdentifier(CSSValueOverline));
 633     if (textDecoration & LINE_THROUGH)
 634         list->append(CSSPrimitiveValue::createIdentifier(CSSValueLineThrough));
 635     if (textDecoration & BLINK)
 636         list->append(CSSPrimitiveValue::createIdentifier(CSSValueBlink));
 637
 638     if (!list->length())
 639         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 640     return list;
 641 }
 642
 643 static PassRefPtr<CSSValue> fillRepeatToCSSValue(EFillRepeat xRepeat, EFillRepeat yRepeat)
 644 {
 645     // For backwards compatibility, if both values are equal, just return one of them. And
 646     // if the two values are equivalent to repeat-x or repeat-y, just return the shorthand.
 647     if (xRepeat == yRepeat)
 648         return CSSPrimitiveValue::create(xRepeat);
 649     if (xRepeat == RepeatFill && yRepeat == NoRepeatFill)
 650         return CSSPrimitiveValue::createIdentifier(CSSValueRepeatX);
 651     if (xRepeat == NoRepeatFill && yRepeat == RepeatFill)
 652         return CSSPrimitiveValue::createIdentifier(CSSValueRepeatY);
 653
 654     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 655     list->append(CSSPrimitiveValue::create(xRepeat));
 656     list->append(CSSPrimitiveValue::create(yRepeat));
 657     return list.release();
 658 }
 659
 660 static void logUnimplementedPropertyID(int propertyID)
 661 {
 662     DEFINE_STATIC_LOCAL(HashSet<int>, propertyIDSet, ());
 663     if (!propertyIDSet.add(propertyID).second)
 664         return;
 665
 666     LOG_ERROR("WebKit does not yet implement getComputedStyle for '%s'.", getPropertyName(static_cast<CSSPropertyID>(propertyID)));
 667 }
 668
 669 PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID, EUpdateLayout updateLayout) const
 670 {
 671     Node* node = m_node.get();
 672     if (!node)
 673         return 0;
 674
 675     // Make sure our layout is up to date before we allow a query on these attributes.
 676     if (updateLayout)
 677         node->document()->updateLayoutIgnorePendingStylesheets();
 678
 679     RenderObject* renderer = node->renderer();
 680
 681     RefPtr<RenderStyle> style;
 682     if (renderer && hasCompositedLayer(renderer) && AnimationController::supportsAcceleratedAnimationOfProperty(static_cast<CSSPropertyID>(propertyID))) {
 683         style = renderer->animation()->getAnimatedStyleForRenderer(renderer);
 684         if (m_pseudoElementSpecifier) {
 685             // FIXME: This cached pseudo style will only exist if the animation has been run at least once.
 686             style = style->getCachedPseudoStyle(m_pseudoElementSpecifier);
 687         }
 688     } else
 689         style = node->computedStyle(m_pseudoElementSpecifier);
 690
 691     if (!style)
 692         return 0;
 693
 694 #ifdef ANDROID_LAYOUT
 695     const Settings * settings = node->document()->frame() ? node->document()->frame()->settings() : 0;
 696 #endif
 697
 698     switch (static_cast<CSSPropertyID>(propertyID)) {
 699         case CSSPropertyInvalid:
 700             break;
 701
 702         case CSSPropertyBackgroundColor:
 703             return CSSPrimitiveValue::createColor(m_allowVisitedStyle? style->visitedDependentColor(CSSPropertyBackgroundColor).rgb() : style->backgroundColor().rgb());
 704         case CSSPropertyBackgroundImage:
 705             if (style->backgroundImage())
 706                 return style->backgroundImage()->cssValue();
 707             return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 708         case CSSPropertyBackgroundSize:
 709         case CSSPropertyWebkitBackgroundSize: {
 710             EFillSizeType size = style->backgroundSizeType();
 711             if (size == Contain)
 712                 return CSSPrimitiveValue::createIdentifier(CSSValueContain);
 713             if (size == Cover)
 714                 return CSSPrimitiveValue::createIdentifier(CSSValueCover);
 715             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 716             list->append(CSSPrimitiveValue::create(style->backgroundSizeLength().width()));
 717             list->append(CSSPrimitiveValue::create(style->backgroundSizeLength().height()));
 718             return list.release();
 719         }
 720         case CSSPropertyBackgroundRepeat:
 721             return fillRepeatToCSSValue(style->backgroundRepeatX(), style->backgroundRepeatY());
 722         case CSSPropertyWebkitBackgroundComposite:
 723             return CSSPrimitiveValue::create(style->backgroundComposite());
 724         case CSSPropertyBackgroundAttachment:
 725             return CSSPrimitiveValue::create(style->backgroundAttachment());
 726         case CSSPropertyBackgroundClip:
 727         case CSSPropertyBackgroundOrigin:
 728         case CSSPropertyWebkitBackgroundClip:
 729         case CSSPropertyWebkitBackgroundOrigin: {
 730             EFillBox box = (propertyID == CSSPropertyWebkitBackgroundClip || propertyID == CSSPropertyBackgroundClip) ? style->backgroundClip() : style->backgroundOrigin();
 731             return CSSPrimitiveValue::create(box);
 732         }
 733         case CSSPropertyBackgroundPosition: {
 734             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 735
 736             list->append(CSSPrimitiveValue::create(style->backgroundXPosition()));
 737             list->append(CSSPrimitiveValue::create(style->backgroundYPosition()));
 738
 739             return list.release();
 740         }
 741         case CSSPropertyBackgroundPositionX:
 742             return CSSPrimitiveValue::create(style->backgroundXPosition());
 743         case CSSPropertyBackgroundPositionY:
 744             return CSSPrimitiveValue::create(style->backgroundYPosition());
 745         case CSSPropertyBorderCollapse:
 746             if (style->borderCollapse())
 747                 return CSSPrimitiveValue::createIdentifier(CSSValueCollapse);
 748             return CSSPrimitiveValue::createIdentifier(CSSValueSeparate);
 749         case CSSPropertyBorderSpacing: {
 750             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 751             list->append(CSSPrimitiveValue::create(style->horizontalBorderSpacing(), CSSPrimitiveValue::CSS_PX));
 752             list->append(CSSPrimitiveValue::create(style->verticalBorderSpacing(), CSSPrimitiveValue::CSS_PX));
 753             return list.release();
 754         }
 755         case CSSPropertyWebkitBorderHorizontalSpacing:
 756             return CSSPrimitiveValue::create(style->horizontalBorderSpacing(), CSSPrimitiveValue::CSS_PX);
 757         case CSSPropertyWebkitBorderVerticalSpacing:
 758             return CSSPrimitiveValue::create(style->verticalBorderSpacing(), CSSPrimitiveValue::CSS_PX);
 759         case CSSPropertyBorderTopColor:
 760             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyBorderTopColor).rgb()) : currentColorOrValidColor(style.get(), style->borderTopColor());
 761         case CSSPropertyBorderRightColor:
 762             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyBorderRightColor).rgb()) : currentColorOrValidColor(style.get(), style->borderRightColor());
 763         case CSSPropertyBorderBottomColor:
 764             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyBorderBottomColor).rgb()) : currentColorOrValidColor(style.get(), style->borderBottomColor());
 765         case CSSPropertyBorderLeftColor:
 766             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyBorderLeftColor).rgb()) : currentColorOrValidColor(style.get(), style->borderLeftColor());
 767         case CSSPropertyBorderTopStyle:
 768             return CSSPrimitiveValue::create(style->borderTopStyle());
 769         case CSSPropertyBorderRightStyle:
 770             return CSSPrimitiveValue::create(style->borderRightStyle());
 771         case CSSPropertyBorderBottomStyle:
 772             return CSSPrimitiveValue::create(style->borderBottomStyle());
 773         case CSSPropertyBorderLeftStyle:
 774             return CSSPrimitiveValue::create(style->borderLeftStyle());
 775         case CSSPropertyBorderTopWidth:
 776             return CSSPrimitiveValue::create(style->borderTopWidth(), CSSPrimitiveValue::CSS_PX);
 777         case CSSPropertyBorderRightWidth:
 778             return CSSPrimitiveValue::create(style->borderRightWidth(), CSSPrimitiveValue::CSS_PX);
 779         case CSSPropertyBorderBottomWidth:
 780             return CSSPrimitiveValue::create(style->borderBottomWidth(), CSSPrimitiveValue::CSS_PX);
 781         case CSSPropertyBorderLeftWidth:
 782             return CSSPrimitiveValue::create(style->borderLeftWidth(), CSSPrimitiveValue::CSS_PX);
 783         case CSSPropertyBottom:
 784             return getPositionOffsetValue(style.get(), CSSPropertyBottom);
 785         case CSSPropertyWebkitBoxAlign:
 786             return CSSPrimitiveValue::create(style->boxAlign());
 787         case CSSPropertyWebkitBoxDirection:
 788             return CSSPrimitiveValue::create(style->boxDirection());
 789         case CSSPropertyWebkitBoxFlex:
 790             return CSSPrimitiveValue::create(style->boxFlex(), CSSPrimitiveValue::CSS_NUMBER);
 791         case CSSPropertyWebkitBoxFlexGroup:
 792             return CSSPrimitiveValue::create(style->boxFlexGroup(), CSSPrimitiveValue::CSS_NUMBER);
 793         case CSSPropertyWebkitBoxLines:
 794             return CSSPrimitiveValue::create(style->boxLines());
 795         case CSSPropertyWebkitBoxOrdinalGroup:
 796             return CSSPrimitiveValue::create(style->boxOrdinalGroup(), CSSPrimitiveValue::CSS_NUMBER);
 797         case CSSPropertyWebkitBoxOrient:
 798             return CSSPrimitiveValue::create(style->boxOrient());
 799         case CSSPropertyWebkitBoxPack: {
 800             EBoxAlignment boxPack = style->boxPack();
 801             ASSERT(boxPack != BSTRETCH);
 802             ASSERT(boxPack != BBASELINE);
 803             if (boxPack == BJUSTIFY || boxPack== BBASELINE)
 804                 return 0;
 805             return CSSPrimitiveValue::create(boxPack);
 806         }
 807         case CSSPropertyWebkitBoxReflect:
 808             return valueForReflection(style->boxReflect());
 809         case CSSPropertyWebkitBoxShadow:
 810             return valueForShadow(style->boxShadow(), propertyID);
 811         case CSSPropertyCaptionSide:
 812             return CSSPrimitiveValue::create(style->captionSide());
 813         case CSSPropertyClear:
 814             return CSSPrimitiveValue::create(style->clear());
 815         case CSSPropertyColor:
 816             return CSSPrimitiveValue::createColor(m_allowVisitedStyle ? style->visitedDependentColor(CSSPropertyColor).rgb() : style->color().rgb());
 817         case CSSPropertyWebkitColumnCount:
 818             if (style->hasAutoColumnCount())
 819                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
 820             return CSSPrimitiveValue::create(style->columnCount(), CSSPrimitiveValue::CSS_NUMBER);
 821         case CSSPropertyWebkitColumnGap:
 822             if (style->hasNormalColumnGap())
 823                 return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 824             return CSSPrimitiveValue::create(style->columnGap(), CSSPrimitiveValue::CSS_NUMBER);
 825         case CSSPropertyWebkitColumnRuleColor:
 826             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style.get(), style->columnRuleColor());
 827         case CSSPropertyWebkitColumnRuleStyle:
 828             return CSSPrimitiveValue::create(style->columnRuleStyle());
 829         case CSSPropertyWebkitColumnRuleWidth:
 830             return CSSPrimitiveValue::create(style->columnRuleWidth(), CSSPrimitiveValue::CSS_PX);
 831         case CSSPropertyWebkitColumnSpan:
 832             if (style->columnSpan())
 833                 return CSSPrimitiveValue::createIdentifier(CSSValueAll);
 834             return CSSPrimitiveValue::create(1, CSSPrimitiveValue::CSS_NUMBER);
 835         case CSSPropertyWebkitColumnBreakAfter:
 836             return CSSPrimitiveValue::create(style->columnBreakAfter());
 837         case CSSPropertyWebkitColumnBreakBefore:
 838             return CSSPrimitiveValue::create(style->columnBreakBefore());
 839         case CSSPropertyWebkitColumnBreakInside:
 840             return CSSPrimitiveValue::create(style->columnBreakInside());
 841         case CSSPropertyWebkitColumnWidth:
 842             if (style->hasAutoColumnWidth())
 843                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
 844             return CSSPrimitiveValue::create(style->columnWidth(), CSSPrimitiveValue::CSS_NUMBER);
 845         case CSSPropertyCursor: {
 846             RefPtr<CSSValueList> list;
 847             CursorList* cursors = style->cursors();
 848             if (cursors && cursors->size() > 0) {
 849                 list = CSSValueList::createCommaSeparated();
 850                 for (unsigned i = 0; i < cursors->size(); ++i)
 851                     list->append(CSSPrimitiveValue::create((*cursors)[i].image()->url(), CSSPrimitiveValue::CSS_URI));
 852             }
 853             RefPtr<CSSValue> value = CSSPrimitiveValue::create(style->cursor());
 854             if (list) {
 855                 list->append(value);
 856                 return list.release();
 857             }
 858             return value.release();
 859         }
 860         case CSSPropertyDirection:
 861             return CSSPrimitiveValue::create(style->direction());
 862         case CSSPropertyDisplay:
 863             return CSSPrimitiveValue::create(style->display());
 864         case CSSPropertyEmptyCells:
 865             return CSSPrimitiveValue::create(style->emptyCells());
 866         case CSSPropertyFloat:
 867 #ifdef ANDROID_LAYOUT
 868             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
 869                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 870 #endif
 871             return CSSPrimitiveValue::create(style->floating());
 872         case CSSPropertyFontFamily: {
 873             const FontFamily& firstFamily = style->fontDescription().family();
 874             if (!firstFamily.next())
 875                 return valueForFamily(firstFamily.family());
 876             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 877             for (const FontFamily* family = &firstFamily; family; family = family->next())
 878                 list->append(valueForFamily(family->family()));
 879             return list.release();
 880         }
 881         case CSSPropertyFontSize:
 882             return CSSPrimitiveValue::create(style->fontDescription().computedPixelSize(), CSSPrimitiveValue::CSS_PX);
 883         case CSSPropertyWebkitBinding:
 884             break;
 885         case CSSPropertyFontStyle:
 886             if (style->fontDescription().italic())
 887                 return CSSPrimitiveValue::createIdentifier(CSSValueItalic);
 888             return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 889         case CSSPropertyFontVariant:
 890             if (style->fontDescription().smallCaps())
 891                 return CSSPrimitiveValue::createIdentifier(CSSValueSmallCaps);
 892             return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 893         case CSSPropertyFontWeight:
 894             switch (style->fontDescription().weight()) {
 895                 case FontWeight100:
 896                     return CSSPrimitiveValue::createIdentifier(CSSValue100);
 897                 case FontWeight200:
 898                     return CSSPrimitiveValue::createIdentifier(CSSValue200);
 899                 case FontWeight300:
 900                     return CSSPrimitiveValue::createIdentifier(CSSValue300);
 901                 case FontWeightNormal:
 902                     return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 903                 case FontWeight500:
 904                     return CSSPrimitiveValue::createIdentifier(CSSValue500);
 905                 case FontWeight600:
 906                     return CSSPrimitiveValue::createIdentifier(CSSValue600);
 907                 case FontWeightBold:
 908                     return CSSPrimitiveValue::createIdentifier(CSSValueBold);
 909                 case FontWeight800:
 910                     return CSSPrimitiveValue::createIdentifier(CSSValue800);
 911                 case FontWeight900:
 912                     return CSSPrimitiveValue::createIdentifier(CSSValue900);
 913             }
 914             ASSERT_NOT_REACHED();
 915             return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 916         case CSSPropertyHeight:
 917             if (renderer)
 918                 return CSSPrimitiveValue::create(sizingBox(renderer).height(), CSSPrimitiveValue::CSS_PX);
 919             return CSSPrimitiveValue::create(style->height());
 920         case CSSPropertyWebkitHighlight:
 921             if (style->highlight() == nullAtom)
 922                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 923             return CSSPrimitiveValue::create(style->highlight(), CSSPrimitiveValue::CSS_STRING);
 924         case CSSPropertyWebkitBorderFit:
 925             if (style->borderFit() == BorderFitBorder)
 926                 return CSSPrimitiveValue::createIdentifier(CSSValueBorder);
 927             return CSSPrimitiveValue::createIdentifier(CSSValueLines);
 928         case CSSPropertyLeft:
 929             return getPositionOffsetValue(style.get(), CSSPropertyLeft);
 930         case CSSPropertyLetterSpacing:
 931             if (!style->letterSpacing())
 932                 return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 933             return CSSPrimitiveValue::create(style->letterSpacing(), CSSPrimitiveValue::CSS_PX);
 934         case CSSPropertyWebkitLineClamp:
 935             if (style->lineClamp().isNone())
 936                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 937             return CSSPrimitiveValue::create(style->lineClamp().value(), style->lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);
 938         case CSSPropertyLineHeight: {
 939             Length length = style->lineHeight();
 940             if (length.isNegative())
 941                 return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 942             if (length.isPercent())
 943                 // This is imperfect, because it doesn't include the zoom factor and the real computation
 944                 // for how high to be in pixels does include things like minimum font size and the zoom factor.
 945                 // On the other hand, since font-size doesn't include the zoom factor, we really can't do
 946                 // that here either.
 947                 return CSSPrimitiveValue::create(static_cast<int>(length.percent() * style->fontDescription().specifiedSize()) / 100, CSSPrimitiveValue::CSS_PX);
 948             return CSSPrimitiveValue::create(length.value(), CSSPrimitiveValue::CSS_PX);
 949         }
 950         case CSSPropertyListStyleImage:
 951             if (style->listStyleImage())
 952                 return style->listStyleImage()->cssValue();
 953             return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 954         case CSSPropertyListStylePosition:
 955             return CSSPrimitiveValue::create(style->listStylePosition());
 956         case CSSPropertyListStyleType:
 957             return CSSPrimitiveValue::create(style->listStyleType());
 958         case CSSPropertyMarginTop:
 959             if (renderer && renderer->isBox())
 960                 // FIXME: Supposed to return the percentage if percentage was specified.
 961                 return CSSPrimitiveValue::create(toRenderBox(renderer)->marginTop(), CSSPrimitiveValue::CSS_PX);
 962             return CSSPrimitiveValue::create(style->marginTop());
 963         case CSSPropertyMarginRight:
 964             if (renderer && renderer->isBox())
 965                 // FIXME: Supposed to return the percentage if percentage was specified.
 966                 return CSSPrimitiveValue::create(toRenderBox(renderer)->marginRight(), CSSPrimitiveValue::CSS_PX);
 967             return CSSPrimitiveValue::create(style->marginRight());
 968         case CSSPropertyMarginBottom:
 969             if (renderer && renderer->isBox())
 970                 // FIXME: Supposed to return the percentage if percentage was specified.
 971                 return CSSPrimitiveValue::create(toRenderBox(renderer)->marginBottom(), CSSPrimitiveValue::CSS_PX);
 972             return CSSPrimitiveValue::create(style->marginBottom());
 973         case CSSPropertyMarginLeft:
 974             if (renderer && renderer->isBox())
 975                 // FIXME: Supposed to return the percentage if percentage was specified.
 976                 return CSSPrimitiveValue::create(toRenderBox(renderer)->marginLeft(), CSSPrimitiveValue::CSS_PX);
 977             return CSSPrimitiveValue::create(style->marginLeft());
 978         case CSSPropertyWebkitMarqueeDirection:
 979             return CSSPrimitiveValue::create(style->marqueeDirection());
 980         case CSSPropertyWebkitMarqueeIncrement:
 981             return CSSPrimitiveValue::create(style->marqueeIncrement());
 982         case CSSPropertyWebkitMarqueeRepetition:
 983             if (style->marqueeLoopCount() < 0)
 984                 return CSSPrimitiveValue::createIdentifier(CSSValueInfinite);
 985             return CSSPrimitiveValue::create(style->marqueeLoopCount(), CSSPrimitiveValue::CSS_NUMBER);
 986         case CSSPropertyWebkitMarqueeStyle:
 987             return CSSPrimitiveValue::create(style->marqueeBehavior());
 988         case CSSPropertyWebkitMaskImage:
 989             if (style->maskImage())
 990                 return style->maskImage()->cssValue();
 991             return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 992         case CSSPropertyWebkitMaskSize: {
 993             EFillSizeType size = style->maskSizeType();
 994             if (size == Contain)
 995                 return CSSPrimitiveValue::createIdentifier(CSSValueContain);
 996             if (size == Cover)
 997                 return CSSPrimitiveValue::createIdentifier(CSSValueCover);
 998             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 999             list->append(CSSPrimitiveValue::create(style->maskSizeLength().width()));
1000             list->append(CSSPrimitiveValue::create(style->maskSizeLength().height()));
1001             return list.release();
1002         }
1003         case CSSPropertyWebkitMaskRepeat:
1004             return fillRepeatToCSSValue(style->maskRepeatX(), style->maskRepeatY());
1005         case CSSPropertyWebkitMaskAttachment:
1006             return CSSPrimitiveValue::create(style->maskAttachment());
1007         case CSSPropertyWebkitMaskComposite:
1008             return CSSPrimitiveValue::create(style->maskComposite());
1009         case CSSPropertyWebkitMaskClip:
1010         case CSSPropertyWebkitMaskOrigin: {
1011             EFillBox box = (propertyID == CSSPropertyWebkitMaskClip ? style->maskClip() : style->maskOrigin());
1012             return CSSPrimitiveValue::create(box);
1013         }
1014         case CSSPropertyWebkitMaskPosition: {
1015             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1016
1017             list->append(CSSPrimitiveValue::create(style->maskXPosition()));
1018             list->append(CSSPrimitiveValue::create(style->maskYPosition()));
1019
1020             return list.release();
1021         }
1022         case CSSPropertyWebkitMaskPositionX:
1023             return CSSPrimitiveValue::create(style->maskXPosition());
1024         case CSSPropertyWebkitMaskPositionY:
1025             return CSSPrimitiveValue::create(style->maskYPosition());
1026         case CSSPropertyWebkitUserModify:
1027             return CSSPrimitiveValue::create(style->userModify());
1028         case CSSPropertyMaxHeight: {
1029             const Length& maxHeight = style->maxHeight();
1030             if (maxHeight.isFixed() && maxHeight.value() == undefinedLength)
1031                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1032             return CSSPrimitiveValue::create(maxHeight);
1033         }
1034         case CSSPropertyMaxWidth: {
1035             const Length& maxWidth = style->maxWidth();
1036             if (maxWidth.isFixed() && maxWidth.value() == undefinedLength)
1037                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1038             return CSSPrimitiveValue::create(maxWidth);
1039         }
1040         case CSSPropertyMinHeight:
1041             return CSSPrimitiveValue::create(style->minHeight());
1042         case CSSPropertyMinWidth:
1043             return CSSPrimitiveValue::create(style->minWidth());
1044         case CSSPropertyOpacity:
1045             return CSSPrimitiveValue::create(style->opacity(), CSSPrimitiveValue::CSS_NUMBER);
1046         case CSSPropertyOrphans:
1047             return CSSPrimitiveValue::create(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);
1048         case CSSPropertyOutlineColor:
1049             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style.get(), style->outlineColor());
1050         case CSSPropertyOutlineStyle:
1051             if (style->outlineStyleIsAuto())
1052                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1053             return CSSPrimitiveValue::create(style->outlineStyle());
1054         case CSSPropertyOutlineWidth:
1055             return CSSPrimitiveValue::create(style->outlineWidth(), CSSPrimitiveValue::CSS_PX);
1056         case CSSPropertyOverflow:
1057             return CSSPrimitiveValue::create(max(style->overflowX(), style->overflowY()));
1058         case CSSPropertyOverflowX:
1059             return CSSPrimitiveValue::create(style->overflowX());
1060         case CSSPropertyOverflowY:
1061 #ifdef ANDROID_LAYOUT
1062             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
1063                 return CSSPrimitiveValue::createIdentifier(CSSValueVisible);
1064 #endif
1065             return CSSPrimitiveValue::create(style->overflowY());
1066         case CSSPropertyPaddingTop:
1067             if (renderer && renderer->isBox())
1068                 return CSSPrimitiveValue::create(toRenderBox(renderer)->paddingTop(false), CSSPrimitiveValue::CSS_PX);
1069             return CSSPrimitiveValue::create(style->paddingTop());
1070         case CSSPropertyPaddingRight:
1071             if (renderer && renderer->isBox())
1072                 return CSSPrimitiveValue::create(toRenderBox(renderer)->paddingRight(false), CSSPrimitiveValue::CSS_PX);
1073             return CSSPrimitiveValue::create(style->paddingRight());
1074         case CSSPropertyPaddingBottom:
1075             if (renderer && renderer->isBox())
1076                 return CSSPrimitiveValue::create(toRenderBox(renderer)->paddingBottom(false), CSSPrimitiveValue::CSS_PX);
1077             return CSSPrimitiveValue::create(style->paddingBottom());
1078         case CSSPropertyPaddingLeft:
1079             if (renderer && renderer->isBox())
1080                 return CSSPrimitiveValue::create(toRenderBox(renderer)->paddingLeft(false), CSSPrimitiveValue::CSS_PX);
1081             return CSSPrimitiveValue::create(style->paddingLeft());
1082         case CSSPropertyPageBreakAfter:
1083             return CSSPrimitiveValue::create(style->pageBreakAfter());
1084         case CSSPropertyPageBreakBefore:
1085             return CSSPrimitiveValue::create(style->pageBreakBefore());
1086         case CSSPropertyPageBreakInside: {
1087             EPageBreak pageBreak = style->pageBreakInside();
1088             ASSERT(pageBreak != PBALWAYS);
1089             if (pageBreak == PBALWAYS)
1090                 return 0;
1091             return CSSPrimitiveValue::create(style->pageBreakInside());
1092         }
1093         case CSSPropertyPosition:
1094 #ifdef ANDROID_LAYOUT
1095             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
1096                 return CSSPrimitiveValue::createIdentifier(CSSValueStatic);
1097 #endif
1098             return CSSPrimitiveValue::create(style->position());
1099         case CSSPropertyRight:
1100             return getPositionOffsetValue(style.get(), CSSPropertyRight);
1101         case CSSPropertyTableLayout:
1102             return CSSPrimitiveValue::create(style->tableLayout());
1103         case CSSPropertyTextAlign:
1104             return CSSPrimitiveValue::create(style->textAlign());
1105         case CSSPropertyTextDecoration:
1106             return renderTextDecorationFlagsToCSSValue(style->textDecoration());
1107         case CSSPropertyWebkitTextDecorationsInEffect:
1108             return renderTextDecorationFlagsToCSSValue(style->textDecorationsInEffect());
1109         case CSSPropertyWebkitTextFillColor:
1110             return currentColorOrValidColor(style.get(), style->textFillColor());
1111         case CSSPropertyTextIndent:
1112             return CSSPrimitiveValue::create(style->textIndent());
1113         case CSSPropertyTextShadow:
1114             return valueForShadow(style->textShadow(), propertyID);
1115         case CSSPropertyTextRendering:
1116             return CSSPrimitiveValue::create(style->fontDescription().textRenderingMode());
1117         case CSSPropertyTextOverflow:
1118             if (style->textOverflow())
1119                 return CSSPrimitiveValue::createIdentifier(CSSValueEllipsis);
1120             return CSSPrimitiveValue::createIdentifier(CSSValueClip);
1121         case CSSPropertyWebkitTextSecurity:
1122             return CSSPrimitiveValue::create(style->textSecurity());
1123         case CSSPropertyWebkitTextSizeAdjust:
1124             if (style->textSizeAdjust())
1125                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1126             return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1127         case CSSPropertyWebkitTextStrokeColor:
1128             return currentColorOrValidColor(style.get(), style->textStrokeColor());
1129         case CSSPropertyWebkitTextStrokeWidth:
1130             return CSSPrimitiveValue::create(style->textStrokeWidth(), CSSPrimitiveValue::CSS_PX);
1131         case CSSPropertyTextTransform:
1132             return CSSPrimitiveValue::create(style->textTransform());
1133         case CSSPropertyTop:
1134             return getPositionOffsetValue(style.get(), CSSPropertyTop);
1135         case CSSPropertyUnicodeBidi:
1136             return CSSPrimitiveValue::create(style->unicodeBidi());
1137         case CSSPropertyVerticalAlign:
1138             switch (style->verticalAlign()) {
1139                 case BASELINE:
1140                     return CSSPrimitiveValue::createIdentifier(CSSValueBaseline);
1141                 case MIDDLE:
1142                     return CSSPrimitiveValue::createIdentifier(CSSValueMiddle);
1143                 case SUB:
1144                     return CSSPrimitiveValue::createIdentifier(CSSValueSub);
1145                 case SUPER:
1146                     return CSSPrimitiveValue::createIdentifier(CSSValueSuper);
1147                 case TEXT_TOP:
1148                     return CSSPrimitiveValue::createIdentifier(CSSValueTextTop);
1149                 case TEXT_BOTTOM:
1150                     return CSSPrimitiveValue::createIdentifier(CSSValueTextBottom);
1151                 case TOP:
1152                     return CSSPrimitiveValue::createIdentifier(CSSValueTop);
1153                 case BOTTOM:
1154                     return CSSPrimitiveValue::createIdentifier(CSSValueBottom);
1155                 case BASELINE_MIDDLE:
1156                     return CSSPrimitiveValue::createIdentifier(CSSValueWebkitBaselineMiddle);
1157                 case LENGTH:
1158                     return CSSPrimitiveValue::create(style->verticalAlignLength());
1159             }
1160             ASSERT_NOT_REACHED();
1161             return 0;
1162         case CSSPropertyVisibility:
1163 #ifdef ANDROID_LAYOUT
1164             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
1165                 return CSSPrimitiveValue::createIdentifier(CSSValueVisible);
1166 #endif
1167             return CSSPrimitiveValue::create(style->visibility());
1168         case CSSPropertyWhiteSpace:
1169 #ifdef ANDROID_LAYOUT
1170             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
1171                 switch (style->whiteSpace()) {
1172                     case NORMAL:
1173                     case NOWRAP:
1174                     case KHTML_NOWRAP:
1175                         return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
1176                     case PRE:
1177                     case PRE_WRAP:
1178                         return CSSPrimitiveValue::createIdentifier(CSSValuePreWrap);
1179                     case PRE_LINE:
1180                         return CSSPrimitiveValue::createIdentifier(CSSValuePreLine);
1181                 }
1182             else
1183 #endif
1184             return CSSPrimitiveValue::create(style->whiteSpace());
1185         case CSSPropertyWidows:
1186             return CSSPrimitiveValue::create(style->widows(), CSSPrimitiveValue::CSS_NUMBER);
1187         case CSSPropertyWidth:
1188             if (renderer)
1189                 return CSSPrimitiveValue::create(sizingBox(renderer).width(), CSSPrimitiveValue::CSS_PX);
1190             return CSSPrimitiveValue::create(style->width());
1191         case CSSPropertyWordBreak:
1192             return CSSPrimitiveValue::create(style->wordBreak());
1193         case CSSPropertyWordSpacing:
1194             return CSSPrimitiveValue::create(style->wordSpacing(), CSSPrimitiveValue::CSS_PX);
1195         case CSSPropertyWordWrap:
1196             return CSSPrimitiveValue::create(style->wordWrap());
1197         case CSSPropertyWebkitLineBreak:
1198             return CSSPrimitiveValue::create(style->khtmlLineBreak());
1199         case CSSPropertyWebkitNbspMode:
1200             return CSSPrimitiveValue::create(style->nbspMode());
1201         case CSSPropertyWebkitMatchNearestMailBlockquoteColor:
1202             return CSSPrimitiveValue::create(style->matchNearestMailBlockquoteColor());
1203         case CSSPropertyResize:
1204             return CSSPrimitiveValue::create(style->resize());
1205         case CSSPropertyWebkitFontSmoothing:
1206             return CSSPrimitiveValue::create(style->fontDescription().fontSmoothing());
1207         case CSSPropertyZIndex:
1208             if (style->hasAutoZIndex())
1209                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1210             return CSSPrimitiveValue::create(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);
1211         case CSSPropertyZoom:
1212             return CSSPrimitiveValue::create(style->zoom(), CSSPrimitiveValue::CSS_NUMBER);
1213         case CSSPropertyWebkitBoxSizing:
1214             if (style->boxSizing() == CONTENT_BOX)
1215                 return CSSPrimitiveValue::createIdentifier(CSSValueContentBox);
1216             return CSSPrimitiveValue::createIdentifier(CSSValueBorderBox);
1217 #if ENABLE(DASHBOARD_SUPPORT)
1218         case CSSPropertyWebkitDashboardRegion:
1219         {
1220             const Vector<StyleDashboardRegion>& regions = style->dashboardRegions();
1221             unsigned count = regions.size();
1222             if (count == 1 && regions[0].type == StyleDashboardRegion::None)
1223                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1224
1225             RefPtr<DashboardRegion> firstRegion;
1226             DashboardRegion* previousRegion = 0;
1227             for (unsigned i = 0; i < count; i++) {
1228                 RefPtr<DashboardRegion> region = DashboardRegion::create();
1229                 StyleDashboardRegion styleRegion = regions[i];
1230
1231                 region->m_label = styleRegion.label;
1232                 LengthBox offset = styleRegion.offset;
1233                 region->setTop(CSSPrimitiveValue::create(offset.top().value(), CSSPrimitiveValue::CSS_PX));
1234                 region->setRight(CSSPrimitiveValue::create(offset.right().value(), CSSPrimitiveValue::CSS_PX));
1235                 region->setBottom(CSSPrimitiveValue::create(offset.bottom().value(), CSSPrimitiveValue::CSS_PX));
1236                 region->setLeft(CSSPrimitiveValue::create(offset.left().value(), CSSPrimitiveValue::CSS_PX));
1237                 region->m_isRectangle = (styleRegion.type == StyleDashboardRegion::Rectangle);
1238                 region->m_isCircle = (styleRegion.type == StyleDashboardRegion::Circle);
1239
1240                 if (previousRegion)
1241                     previousRegion->m_next = region;
1242                 else
1243                     firstRegion = region;
1244                 previousRegion = region.get();
1245             }
1246             return CSSPrimitiveValue::create(firstRegion.release());
1247         }
1248 #endif
1249         case CSSPropertyWebkitAnimationDelay:
1250             return getDelayValue(style->animations());
1251         case CSSPropertyWebkitAnimationDirection: {
1252             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1253             const AnimationList* t = style->animations();
1254             if (t) {
1255                 for (size_t i = 0; i < t->size(); ++i) {
1256                     if (t->animation(i)->direction())
1257                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueAlternate));
1258                     else
1259                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueNormal));
1260                 }
1261             } else
1262                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueNormal));
1263             return list.release();
1264         }
1265         case CSSPropertyWebkitAnimationDuration:
1266             return getDurationValue(style->animations());
1267         case CSSPropertyWebkitAnimationFillMode: {
1268             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1269             const AnimationList* t = style->animations();
1270             if (t) {
1271                 for (size_t i = 0; i < t->size(); ++i) {
1272                     switch (t->animation(i)->fillMode()) {
1273                     case AnimationFillModeNone:
1274                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
1275                         break;
1276                     case AnimationFillModeForwards:
1277                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueForwards));
1278                         break;
1279                     case AnimationFillModeBackwards:
1280                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueBackwards));
1281                         break;
1282                     case AnimationFillModeBoth:
1283                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueBoth));
1284                         break;
1285                     }
1286                 }
1287             } else
1288                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
1289             return list.release();
1290         }
1291         case CSSPropertyWebkitAnimationIterationCount: {
1292             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1293             const AnimationList* t = style->animations();
1294             if (t) {
1295                 for (size_t i = 0; i < t->size(); ++i) {
1296                     int iterationCount = t->animation(i)->iterationCount();
1297                     if (iterationCount == Animation::IterationCountInfinite)
1298                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueInfinite));
1299                     else
1300                         list->append(CSSPrimitiveValue::create(iterationCount, CSSPrimitiveValue::CSS_NUMBER));
1301                 }
1302             } else
1303                 list->append(CSSPrimitiveValue::create(Animation::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
1304             return list.release();
1305         }
1306         case CSSPropertyWebkitAnimationName: {
1307             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1308             const AnimationList* t = style->animations();
1309             if (t) {
1310                 for (size_t i = 0; i < t->size(); ++i) {
1311                     list->append(CSSPrimitiveValue::create(t->animation(i)->name(), CSSPrimitiveValue::CSS_STRING));
1312                 }
1313             } else
1314                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
1315             return list.release();
1316         }
1317         case CSSPropertyWebkitAnimationPlayState: {
1318             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1319             const AnimationList* t = style->animations();
1320             if (t) {
1321                 for (size_t i = 0; i < t->size(); ++i) {
1322                     int prop = t->animation(i)->playState();
1323                     if (prop == AnimPlayStatePlaying)
1324                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueRunning));
1325                     else
1326                         list->append(CSSPrimitiveValue::createIdentifier(CSSValuePaused));
1327                 }
1328             } else
1329                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueRunning));
1330             return list.release();
1331         }
1332         case CSSPropertyWebkitAnimationTimingFunction:
1333             return getTimingFunctionValue(style->animations());
1334         case CSSPropertyWebkitAppearance:
1335             return CSSPrimitiveValue::create(style->appearance());
1336         case CSSPropertyWebkitBackfaceVisibility:
1337             return CSSPrimitiveValue::createIdentifier((style->backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
1338         case CSSPropertyWebkitBorderImage:
1339             return valueForNinePieceImage(style->borderImage());
1340         case CSSPropertyWebkitMaskBoxImage:
1341             return valueForNinePieceImage(style->maskBoxImage());
1342         case CSSPropertyWebkitFontSizeDelta:
1343             // Not a real style property -- used by the editing engine -- so has no computed value.
1344             break;
1345         case CSSPropertyWebkitMarginBottomCollapse:
1346             return CSSPrimitiveValue::create(style->marginBottomCollapse());
1347         case CSSPropertyWebkitMarginTopCollapse:
1348             return CSSPrimitiveValue::create(style->marginTopCollapse());
1349         case CSSPropertyWebkitPerspective:
1350             if (!style->hasPerspective())
1351                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1352             return CSSPrimitiveValue::create(style->perspective(), CSSPrimitiveValue::CSS_NUMBER);
1353         case CSSPropertyWebkitPerspectiveOrigin: {
1354             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1355             if (renderer) {
1356                 IntRect box = sizingBox(renderer);
1357                 list->append(CSSPrimitiveValue::create(style->perspectiveOriginX().calcMinValue(box.width()), CSSPrimitiveValue::CSS_PX));
1358                 list->append(CSSPrimitiveValue::create(style->perspectiveOriginY().calcMinValue(box.height()), CSSPrimitiveValue::CSS_PX));
1359             }
1360             else {
1361                 list->append(CSSPrimitiveValue::create(style->perspectiveOriginX()));
1362                 list->append(CSSPrimitiveValue::create(style->perspectiveOriginY()));
1363             }
1364             return list.release();
1365         }
1366         case CSSPropertyWebkitRtlOrdering:
1367             if (style->visuallyOrdered())
1368                 return CSSPrimitiveValue::createIdentifier(CSSValueVisual);
1369             return CSSPrimitiveValue::createIdentifier(CSSValueLogical);
1370         case CSSPropertyWebkitUserDrag:
1371             return CSSPrimitiveValue::create(style->userDrag());
1372         case CSSPropertyWebkitUserSelect:
1373             return CSSPrimitiveValue::create(style->userSelect());
1374         case CSSPropertyBorderBottomLeftRadius:
1375             return getBorderRadiusCornerValue(style->borderBottomLeftRadius());
1376         case CSSPropertyBorderBottomRightRadius:
1377             return getBorderRadiusCornerValue(style->borderBottomRightRadius());
1378         case CSSPropertyBorderTopLeftRadius:
1379             return getBorderRadiusCornerValue(style->borderTopLeftRadius());
1380         case CSSPropertyBorderTopRightRadius:
1381             return getBorderRadiusCornerValue(style->borderTopRightRadius());
1382         case CSSPropertyClip: {
1383             if (!style->hasClip())
1384                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1385             RefPtr<Rect> rect = Rect::create();
1386             rect->setTop(CSSPrimitiveValue::create(style->clip().top().value(), CSSPrimitiveValue::CSS_PX));
1387             rect->setRight(CSSPrimitiveValue::create(style->clip().right().value(), CSSPrimitiveValue::CSS_PX));
1388             rect->setBottom(CSSPrimitiveValue::create(style->clip().bottom().value(), CSSPrimitiveValue::CSS_PX));
1389             rect->setLeft(CSSPrimitiveValue::create(style->clip().left().value(), CSSPrimitiveValue::CSS_PX));
1390             return CSSPrimitiveValue::create(rect.release());
1391         }
1392         case CSSPropertyWebkitTransform:
1393             return computedTransform(renderer, style.get());
1394         case CSSPropertyWebkitTransformOrigin: {
1395             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1396             if (renderer) {
1397                 IntRect box = sizingBox(renderer);
1398                 list->append(CSSPrimitiveValue::create(style->transformOriginX().calcMinValue(box.width()), CSSPrimitiveValue::CSS_PX));
1399                 list->append(CSSPrimitiveValue::create(style->transformOriginY().calcMinValue(box.height()), CSSPrimitiveValue::CSS_PX));
1400                 if (style->transformOriginZ() != 0)
1401                     list->append(CSSPrimitiveValue::create(style->transformOriginZ(), CSSPrimitiveValue::CSS_PX));
1402             } else {
1403                 list->append(CSSPrimitiveValue::create(style->transformOriginX()));
1404                 list->append(CSSPrimitiveValue::create(style->transformOriginY()));
1405                 if (style->transformOriginZ() != 0)
1406                     list->append(CSSPrimitiveValue::create(style->transformOriginZ(), CSSPrimitiveValue::CSS_PX));
1407             }
1408             return list.release();
1409         }
1410         case CSSPropertyWebkitTransformStyle:
1411             return CSSPrimitiveValue::createIdentifier((style->transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
1412         case CSSPropertyWebkitTransitionDelay:
1413             return getDelayValue(style->transitions());
1414         case CSSPropertyWebkitTransitionDuration:
1415             return getDurationValue(style->transitions());
1416         case CSSPropertyWebkitTransitionProperty: {
1417             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1418             const AnimationList* t = style->transitions();
1419             if (t) {
1420                 for (size_t i = 0; i < t->size(); ++i) {
1421                     int prop = t->animation(i)->property();
1422                     RefPtr<CSSValue> propertyValue;
1423                     if (prop == cAnimateNone)
1424                         propertyValue = CSSPrimitiveValue::createIdentifier(CSSValueNone);
1425                     else if (prop == cAnimateAll)
1426                         propertyValue = CSSPrimitiveValue::createIdentifier(CSSValueAll);
1427                     else
1428                         propertyValue = CSSPrimitiveValue::create(getPropertyName(static_cast<CSSPropertyID>(prop)), CSSPrimitiveValue::CSS_STRING);
1429                     list->append(propertyValue);
1430                 }
1431             } else
1432                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueAll));
1433             return list.release();
1434         }
1435         case CSSPropertyWebkitTransitionTimingFunction:
1436             return getTimingFunctionValue(style->transitions());
1437         case CSSPropertyPointerEvents:
1438             return CSSPrimitiveValue::create(style->pointerEvents());
1439         case CSSPropertyWebkitColorCorrection:
1440             return CSSPrimitiveValue::create(style->colorSpace());
1441
1442         /* Shorthand properties, currently not supported see bug 13658*/
1443         case CSSPropertyBackground:
1444         case CSSPropertyBorder:
1445         case CSSPropertyBorderBottom:
1446         case CSSPropertyBorderColor:
1447         case CSSPropertyBorderLeft:
1448         case CSSPropertyBorderRadius:
1449         case CSSPropertyBorderRight:
1450         case CSSPropertyBorderStyle:
1451         case CSSPropertyBorderTop:
1452         case CSSPropertyBorderWidth:
1453         case CSSPropertyFont:
1454         case CSSPropertyListStyle:
1455         case CSSPropertyMargin:
1456         case CSSPropertyPadding:
1457             break;
1458
1459         /* Unimplemented CSS 3 properties (including CSS3 shorthand properties) */
1460         case CSSPropertyTextLineThrough:
1461         case CSSPropertyTextLineThroughColor:
1462         case CSSPropertyTextLineThroughMode:
1463         case CSSPropertyTextLineThroughStyle:
1464         case CSSPropertyTextLineThroughWidth:
1465         case CSSPropertyTextOverline:
1466         case CSSPropertyTextOverlineColor:
1467         case CSSPropertyTextOverlineMode:
1468         case CSSPropertyTextOverlineStyle:
1469         case CSSPropertyTextOverlineWidth:
1470         case CSSPropertyTextUnderline:
1471         case CSSPropertyTextUnderlineColor:
1472         case CSSPropertyTextUnderlineMode:
1473         case CSSPropertyTextUnderlineStyle:
1474         case CSSPropertyTextUnderlineWidth:
1475             break;
1476
1477         /* Unimplemented @font-face properties */
1478         case CSSPropertyFontStretch:
1479         case CSSPropertySrc:
1480         case CSSPropertyUnicodeRange:
1481             break;
1482
1483         /* Other unimplemented properties */
1484         case CSSPropertyBackgroundRepeatX:
1485         case CSSPropertyBackgroundRepeatY:
1486         case CSSPropertyContent: // FIXME: needs implementation, bug 23668
1487         case CSSPropertyCounterIncrement:
1488         case CSSPropertyCounterReset:
1489         case CSSPropertyOutline: // FIXME: needs implementation
1490         case CSSPropertyOutlineOffset: // FIXME: needs implementation
1491         case CSSPropertyPage: // for @page
1492         case CSSPropertyQuotes: // FIXME: needs implementation
1493         case CSSPropertySize: // for @page
1494             break;
1495
1496         /* Unimplemented -webkit- properties */
1497         case CSSPropertyWebkitAnimation:
1498         case CSSPropertyWebkitBorderRadius:
1499         case CSSPropertyWebkitColumns:
1500         case CSSPropertyWebkitColumnRule:
1501         case CSSPropertyWebkitMarginCollapse:
1502         case CSSPropertyWebkitMarginStart:
1503         case CSSPropertyWebkitMarquee:
1504         case CSSPropertyWebkitMarqueeSpeed:
1505         case CSSPropertyWebkitMask:
1506         case CSSPropertyWebkitMaskRepeatX:
1507         case CSSPropertyWebkitMaskRepeatY:
1508         case CSSPropertyWebkitPaddingStart:
1509         case CSSPropertyWebkitPerspectiveOriginX:
1510         case CSSPropertyWebkitPerspectiveOriginY:
1511         case CSSPropertyWebkitTextStroke:
1512         case CSSPropertyWebkitTransformOriginX:
1513         case CSSPropertyWebkitTransformOriginY:
1514         case CSSPropertyWebkitTransformOriginZ:
1515         case CSSPropertyWebkitTransition:
1516         case CSSPropertyWebkitVariableDeclarationBlock:
1517             break;
1518 #ifdef ANDROID_CSS_TAP_HIGHLIGHT_COLOR
1519         case CSSPropertyWebkitTapHighlightColor:
1520             return CSSPrimitiveValue::createColor(style->tapHighlightColor().rgb());
1521 #endif
1522 #if ENABLE(SVG)
1523         // FIXME: This default case ruins the point of using an enum for
1524         // properties -- it prevents us from getting a warning when we
1525         // forget to list a property above.
1526         default:
1527             return getSVGPropertyCSSValue(propertyID, DoNotUpdateLayout);
1528 #endif
1529     }
1530
1531     logUnimplementedPropertyID(propertyID);
1532     return 0;
1533 }
1534
1535 String CSSComputedStyleDeclaration::getPropertyValue(int propertyID) const
1536 {
1537     RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);
1538     if (value)
1539         return value->cssText();
1540     return "";
1541 }
1542
1543 bool CSSComputedStyleDeclaration::getPropertyPriority(int /*propertyID*/) const
1544 {
1545     // All computed styles have a priority of false (not "important").
1546     return false;
1547 }
1548
1549 String CSSComputedStyleDeclaration::removeProperty(int /*propertyID*/, ExceptionCode& ec)
1550 {
1551     ec = NO_MODIFICATION_ALLOWED_ERR;
1552     return String();
1553 }
1554
1555 void CSSComputedStyleDeclaration::setProperty(int /*propertyID*/, const String& /*value*/, bool /*important*/, ExceptionCode& ec)
1556 {
1557     ec = NO_MODIFICATION_ALLOWED_ERR;
1558 }
1559
1560 unsigned CSSComputedStyleDeclaration::virtualLength() const
1561 {
1562     Node* node = m_node.get();
1563     if (!node)
1564         return 0;
1565
1566     RenderStyle* style = node->computedStyle(m_pseudoElementSpecifier);
1567     if (!style)
1568         return 0;
1569
1570     return numComputedProperties;
1571 }
1572
1573 String CSSComputedStyleDeclaration::item(unsigned i) const
1574 {
1575     if (i >= length())
1576         return "";
1577
1578     return getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));
1579 }
1580
1581 bool CSSComputedStyleDeclaration::cssPropertyMatches(const CSSProperty* property) const
1582 {
1583     if (property->id() == CSSPropertyFontSize && property->value()->isPrimitiveValue() && m_node) {
1584         m_node->document()->updateLayoutIgnorePendingStylesheets();
1585         RenderStyle* style = m_node->computedStyle(m_pseudoElementSpecifier);
1586         if (style && style->fontDescription().keywordSize()) {
1587             int sizeValue = cssIdentifierForFontSizeKeyword(style->fontDescription().keywordSize());
1588             CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(property->value());
1589             if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_IDENT && primitiveValue->getIdent() == sizeValue)
1590                 return true;
1591         }
1592     }
1593
1594     return CSSStyleDeclaration::cssPropertyMatches(property);
1595 }
1596
1597 PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::copy() const
1598 {
1599     return copyPropertiesInSet(computedProperties, numComputedProperties);
1600 }
1601
1602 PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::makeMutable()
1603 {
1604     return copy();
1605 }
1606
1607 } // namespace WebCore