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