WebCore/css/CSSComputedStyleDeclaration.cpp

   1 /*
   2  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
   3  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 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     propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style->direction());
 695 #ifdef ANDROID_LAYOUT
 696     const Settings * settings = node->document()->frame() ? node->document()->frame()->settings() : 0;
 697 #endif
 698
 699     switch (static_cast<CSSPropertyID>(propertyID)) {
 700         case CSSPropertyInvalid:
 701             break;
 702
 703         case CSSPropertyBackgroundColor:
 704             return CSSPrimitiveValue::createColor(m_allowVisitedStyle? style->visitedDependentColor(CSSPropertyBackgroundColor).rgb() : style->backgroundColor().rgb());
 705         case CSSPropertyBackgroundImage:
 706             if (style->backgroundImage())
 707                 return style->backgroundImage()->cssValue();
 708             return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 709         case CSSPropertyBackgroundSize:
 710         case CSSPropertyWebkitBackgroundSize: {
 711             EFillSizeType size = style->backgroundSizeType();
 712             if (size == Contain)
 713                 return CSSPrimitiveValue::createIdentifier(CSSValueContain);
 714             if (size == Cover)
 715                 return CSSPrimitiveValue::createIdentifier(CSSValueCover);
 716             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 717             list->append(CSSPrimitiveValue::create(style->backgroundSizeLength().width()));
 718             list->append(CSSPrimitiveValue::create(style->backgroundSizeLength().height()));
 719             return list.release();
 720         }
 721         case CSSPropertyBackgroundRepeat:
 722             return fillRepeatToCSSValue(style->backgroundRepeatX(), style->backgroundRepeatY());
 723         case CSSPropertyWebkitBackgroundComposite:
 724             return CSSPrimitiveValue::create(style->backgroundComposite());
 725         case CSSPropertyBackgroundAttachment:
 726             return CSSPrimitiveValue::create(style->backgroundAttachment());
 727         case CSSPropertyBackgroundClip:
 728         case CSSPropertyBackgroundOrigin:
 729         case CSSPropertyWebkitBackgroundClip:
 730         case CSSPropertyWebkitBackgroundOrigin: {
 731             EFillBox box = (propertyID == CSSPropertyWebkitBackgroundClip || propertyID == CSSPropertyBackgroundClip) ? style->backgroundClip() : style->backgroundOrigin();
 732             return CSSPrimitiveValue::create(box);
 733         }
 734         case CSSPropertyBackgroundPosition: {
 735             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 736
 737             list->append(CSSPrimitiveValue::create(style->backgroundXPosition()));
 738             list->append(CSSPrimitiveValue::create(style->backgroundYPosition()));
 739
 740             return list.release();
 741         }
 742         case CSSPropertyBackgroundPositionX:
 743             return CSSPrimitiveValue::create(style->backgroundXPosition());
 744         case CSSPropertyBackgroundPositionY:
 745             return CSSPrimitiveValue::create(style->backgroundYPosition());
 746         case CSSPropertyBorderCollapse:
 747             if (style->borderCollapse())
 748                 return CSSPrimitiveValue::createIdentifier(CSSValueCollapse);
 749             return CSSPrimitiveValue::createIdentifier(CSSValueSeparate);
 750         case CSSPropertyBorderSpacing: {
 751             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 752             list->append(CSSPrimitiveValue::create(style->horizontalBorderSpacing(), CSSPrimitiveValue::CSS_PX));
 753             list->append(CSSPrimitiveValue::create(style->verticalBorderSpacing(), CSSPrimitiveValue::CSS_PX));
 754             return list.release();
 755         }
 756         case CSSPropertyWebkitBorderHorizontalSpacing:
 757             return CSSPrimitiveValue::create(style->horizontalBorderSpacing(), CSSPrimitiveValue::CSS_PX);
 758         case CSSPropertyWebkitBorderVerticalSpacing:
 759             return CSSPrimitiveValue::create(style->verticalBorderSpacing(), CSSPrimitiveValue::CSS_PX);
 760         case CSSPropertyBorderTopColor:
 761             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyBorderTopColor).rgb()) : currentColorOrValidColor(style.get(), style->borderTopColor());
 762         case CSSPropertyBorderRightColor:
 763             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyBorderRightColor).rgb()) : currentColorOrValidColor(style.get(), style->borderRightColor());
 764         case CSSPropertyBorderBottomColor:
 765             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyBorderBottomColor).rgb()) : currentColorOrValidColor(style.get(), style->borderBottomColor());
 766         case CSSPropertyBorderLeftColor:
 767             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyBorderLeftColor).rgb()) : currentColorOrValidColor(style.get(), style->borderLeftColor());
 768         case CSSPropertyBorderTopStyle:
 769             return CSSPrimitiveValue::create(style->borderTopStyle());
 770         case CSSPropertyBorderRightStyle:
 771             return CSSPrimitiveValue::create(style->borderRightStyle());
 772         case CSSPropertyBorderBottomStyle:
 773             return CSSPrimitiveValue::create(style->borderBottomStyle());
 774         case CSSPropertyBorderLeftStyle:
 775             return CSSPrimitiveValue::create(style->borderLeftStyle());
 776         case CSSPropertyBorderTopWidth:
 777             return CSSPrimitiveValue::create(style->borderTopWidth(), CSSPrimitiveValue::CSS_PX);
 778         case CSSPropertyBorderRightWidth:
 779             return CSSPrimitiveValue::create(style->borderRightWidth(), CSSPrimitiveValue::CSS_PX);
 780         case CSSPropertyBorderBottomWidth:
 781             return CSSPrimitiveValue::create(style->borderBottomWidth(), CSSPrimitiveValue::CSS_PX);
 782         case CSSPropertyBorderLeftWidth:
 783             return CSSPrimitiveValue::create(style->borderLeftWidth(), CSSPrimitiveValue::CSS_PX);
 784         case CSSPropertyBottom:
 785             return getPositionOffsetValue(style.get(), CSSPropertyBottom);
 786         case CSSPropertyWebkitBoxAlign:
 787             return CSSPrimitiveValue::create(style->boxAlign());
 788         case CSSPropertyWebkitBoxDirection:
 789             return CSSPrimitiveValue::create(style->boxDirection());
 790         case CSSPropertyWebkitBoxFlex:
 791             return CSSPrimitiveValue::create(style->boxFlex(), CSSPrimitiveValue::CSS_NUMBER);
 792         case CSSPropertyWebkitBoxFlexGroup:
 793             return CSSPrimitiveValue::create(style->boxFlexGroup(), CSSPrimitiveValue::CSS_NUMBER);
 794         case CSSPropertyWebkitBoxLines:
 795             return CSSPrimitiveValue::create(style->boxLines());
 796         case CSSPropertyWebkitBoxOrdinalGroup:
 797             return CSSPrimitiveValue::create(style->boxOrdinalGroup(), CSSPrimitiveValue::CSS_NUMBER);
 798         case CSSPropertyWebkitBoxOrient:
 799             return CSSPrimitiveValue::create(style->boxOrient());
 800         case CSSPropertyWebkitBoxPack: {
 801             EBoxAlignment boxPack = style->boxPack();
 802             ASSERT(boxPack != BSTRETCH);
 803             ASSERT(boxPack != BBASELINE);
 804             if (boxPack == BJUSTIFY || boxPack== BBASELINE)
 805                 return 0;
 806             return CSSPrimitiveValue::create(boxPack);
 807         }
 808         case CSSPropertyWebkitBoxReflect:
 809             return valueForReflection(style->boxReflect());
 810         case CSSPropertyWebkitBoxShadow:
 811             return valueForShadow(style->boxShadow(), propertyID);
 812         case CSSPropertyCaptionSide:
 813             return CSSPrimitiveValue::create(style->captionSide());
 814         case CSSPropertyClear:
 815             return CSSPrimitiveValue::create(style->clear());
 816         case CSSPropertyColor:
 817             return CSSPrimitiveValue::createColor(m_allowVisitedStyle ? style->visitedDependentColor(CSSPropertyColor).rgb() : style->color().rgb());
 818         case CSSPropertyWebkitColumnCount:
 819             if (style->hasAutoColumnCount())
 820                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
 821             return CSSPrimitiveValue::create(style->columnCount(), CSSPrimitiveValue::CSS_NUMBER);
 822         case CSSPropertyWebkitColumnGap:
 823             if (style->hasNormalColumnGap())
 824                 return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 825             return CSSPrimitiveValue::create(style->columnGap(), CSSPrimitiveValue::CSS_NUMBER);
 826         case CSSPropertyWebkitColumnRuleColor:
 827             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style.get(), style->columnRuleColor());
 828         case CSSPropertyWebkitColumnRuleStyle:
 829             return CSSPrimitiveValue::create(style->columnRuleStyle());
 830         case CSSPropertyWebkitColumnRuleWidth:
 831             return CSSPrimitiveValue::create(style->columnRuleWidth(), CSSPrimitiveValue::CSS_PX);
 832         case CSSPropertyWebkitColumnSpan:
 833             if (style->columnSpan())
 834                 return CSSPrimitiveValue::createIdentifier(CSSValueAll);
 835             return CSSPrimitiveValue::create(1, CSSPrimitiveValue::CSS_NUMBER);
 836         case CSSPropertyWebkitColumnBreakAfter:
 837             return CSSPrimitiveValue::create(style->columnBreakAfter());
 838         case CSSPropertyWebkitColumnBreakBefore:
 839             return CSSPrimitiveValue::create(style->columnBreakBefore());
 840         case CSSPropertyWebkitColumnBreakInside:
 841             return CSSPrimitiveValue::create(style->columnBreakInside());
 842         case CSSPropertyWebkitColumnWidth:
 843             if (style->hasAutoColumnWidth())
 844                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
 845             return CSSPrimitiveValue::create(style->columnWidth(), CSSPrimitiveValue::CSS_NUMBER);
 846         case CSSPropertyCursor: {
 847             RefPtr<CSSValueList> list;
 848             CursorList* cursors = style->cursors();
 849             if (cursors && cursors->size() > 0) {
 850                 list = CSSValueList::createCommaSeparated();
 851                 for (unsigned i = 0; i < cursors->size(); ++i)
 852                     list->append(CSSPrimitiveValue::create((*cursors)[i].image()->url(), CSSPrimitiveValue::CSS_URI));
 853             }
 854             RefPtr<CSSValue> value = CSSPrimitiveValue::create(style->cursor());
 855             if (list) {
 856                 list->append(value);
 857                 return list.release();
 858             }
 859             return value.release();
 860         }
 861         case CSSPropertyDirection:
 862             return CSSPrimitiveValue::create(style->direction());
 863         case CSSPropertyDisplay:
 864             return CSSPrimitiveValue::create(style->display());
 865         case CSSPropertyEmptyCells:
 866             return CSSPrimitiveValue::create(style->emptyCells());
 867         case CSSPropertyFloat:
 868 #ifdef ANDROID_LAYOUT
 869             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
 870                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 871 #endif
 872             return CSSPrimitiveValue::create(style->floating());
 873         case CSSPropertyFontFamily: {
 874             const FontFamily& firstFamily = style->fontDescription().family();
 875             if (!firstFamily.next())
 876                 return valueForFamily(firstFamily.family());
 877             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 878             for (const FontFamily* family = &firstFamily; family; family = family->next())
 879                 list->append(valueForFamily(family->family()));
 880             return list.release();
 881         }
 882         case CSSPropertyFontSize:
 883             return CSSPrimitiveValue::create(style->fontDescription().computedPixelSize(), CSSPrimitiveValue::CSS_PX);
 884         case CSSPropertyWebkitBinding:
 885             break;
 886         case CSSPropertyFontStyle:
 887             if (style->fontDescription().italic())
 888                 return CSSPrimitiveValue::createIdentifier(CSSValueItalic);
 889             return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 890         case CSSPropertyFontVariant:
 891             if (style->fontDescription().smallCaps())
 892                 return CSSPrimitiveValue::createIdentifier(CSSValueSmallCaps);
 893             return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 894         case CSSPropertyFontWeight:
 895             switch (style->fontDescription().weight()) {
 896                 case FontWeight100:
 897                     return CSSPrimitiveValue::createIdentifier(CSSValue100);
 898                 case FontWeight200:
 899                     return CSSPrimitiveValue::createIdentifier(CSSValue200);
 900                 case FontWeight300:
 901                     return CSSPrimitiveValue::createIdentifier(CSSValue300);
 902                 case FontWeightNormal:
 903                     return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 904                 case FontWeight500:
 905                     return CSSPrimitiveValue::createIdentifier(CSSValue500);
 906                 case FontWeight600:
 907                     return CSSPrimitiveValue::createIdentifier(CSSValue600);
 908                 case FontWeightBold:
 909                     return CSSPrimitiveValue::createIdentifier(CSSValueBold);
 910                 case FontWeight800:
 911                     return CSSPrimitiveValue::createIdentifier(CSSValue800);
 912                 case FontWeight900:
 913                     return CSSPrimitiveValue::createIdentifier(CSSValue900);
 914             }
 915             ASSERT_NOT_REACHED();
 916             return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 917         case CSSPropertyHeight:
 918             if (renderer)
 919                 return CSSPrimitiveValue::create(sizingBox(renderer).height(), CSSPrimitiveValue::CSS_PX);
 920             return CSSPrimitiveValue::create(style->height());
 921         case CSSPropertyWebkitHighlight:
 922             if (style->highlight() == nullAtom)
 923                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 924             return CSSPrimitiveValue::create(style->highlight(), CSSPrimitiveValue::CSS_STRING);
 925         case CSSPropertyWebkitHyphens:
 926             return CSSPrimitiveValue::create(style->hyphens());
 927         case CSSPropertyWebkitHyphenateCharacter:
 928             if (style->hyphenationString().isNull())
 929                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
 930             return CSSPrimitiveValue::create(style->hyphenationString(), CSSPrimitiveValue::CSS_STRING);
 931         case CSSPropertyWebkitHyphenateLocale:
 932             if (style->hyphenationLocale().isNull())
 933                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
 934             return CSSPrimitiveValue::create(style->hyphenationLocale(), CSSPrimitiveValue::CSS_STRING);
 935         case CSSPropertyWebkitBorderFit:
 936             if (style->borderFit() == BorderFitBorder)
 937                 return CSSPrimitiveValue::createIdentifier(CSSValueBorder);
 938             return CSSPrimitiveValue::createIdentifier(CSSValueLines);
 939         case CSSPropertyLeft:
 940             return getPositionOffsetValue(style.get(), CSSPropertyLeft);
 941         case CSSPropertyLetterSpacing:
 942             if (!style->letterSpacing())
 943                 return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 944             return CSSPrimitiveValue::create(style->letterSpacing(), CSSPrimitiveValue::CSS_PX);
 945         case CSSPropertyWebkitLineClamp:
 946             if (style->lineClamp().isNone())
 947                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 948             return CSSPrimitiveValue::create(style->lineClamp().value(), style->lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);
 949         case CSSPropertyLineHeight: {
 950             Length length = style->lineHeight();
 951             if (length.isNegative())
 952                 return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
 953             if (length.isPercent())
 954                 // This is imperfect, because it doesn't include the zoom factor and the real computation
 955                 // for how high to be in pixels does include things like minimum font size and the zoom factor.
 956                 // On the other hand, since font-size doesn't include the zoom factor, we really can't do
 957                 // that here either.
 958                 return CSSPrimitiveValue::create(static_cast<int>(length.percent() * style->fontDescription().specifiedSize()) / 100, CSSPrimitiveValue::CSS_PX);
 959             return CSSPrimitiveValue::create(length.value(), CSSPrimitiveValue::CSS_PX);
 960         }
 961         case CSSPropertyListStyleImage:
 962             if (style->listStyleImage())
 963                 return style->listStyleImage()->cssValue();
 964             return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 965         case CSSPropertyListStylePosition:
 966             return CSSPrimitiveValue::create(style->listStylePosition());
 967         case CSSPropertyListStyleType:
 968             return CSSPrimitiveValue::create(style->listStyleType());
 969         case CSSPropertyMarginTop:
 970             if (renderer && renderer->isBox())
 971                 // FIXME: Supposed to return the percentage if percentage was specified.
 972                 return CSSPrimitiveValue::create(toRenderBox(renderer)->marginTop(), CSSPrimitiveValue::CSS_PX);
 973             return CSSPrimitiveValue::create(style->marginTop());
 974         case CSSPropertyMarginRight:
 975             if (renderer && renderer->isBox())
 976                 // FIXME: Supposed to return the percentage if percentage was specified.
 977                 return CSSPrimitiveValue::create(toRenderBox(renderer)->marginRight(), CSSPrimitiveValue::CSS_PX);
 978             return CSSPrimitiveValue::create(style->marginRight());
 979         case CSSPropertyMarginBottom:
 980             if (renderer && renderer->isBox())
 981                 // FIXME: Supposed to return the percentage if percentage was specified.
 982                 return CSSPrimitiveValue::create(toRenderBox(renderer)->marginBottom(), CSSPrimitiveValue::CSS_PX);
 983             return CSSPrimitiveValue::create(style->marginBottom());
 984         case CSSPropertyMarginLeft:
 985             if (renderer && renderer->isBox())
 986                 // FIXME: Supposed to return the percentage if percentage was specified.
 987                 return CSSPrimitiveValue::create(toRenderBox(renderer)->marginLeft(), CSSPrimitiveValue::CSS_PX);
 988             return CSSPrimitiveValue::create(style->marginLeft());
 989         case CSSPropertyWebkitMarqueeDirection:
 990             return CSSPrimitiveValue::create(style->marqueeDirection());
 991         case CSSPropertyWebkitMarqueeIncrement:
 992             return CSSPrimitiveValue::create(style->marqueeIncrement());
 993         case CSSPropertyWebkitMarqueeRepetition:
 994             if (style->marqueeLoopCount() < 0)
 995                 return CSSPrimitiveValue::createIdentifier(CSSValueInfinite);
 996             return CSSPrimitiveValue::create(style->marqueeLoopCount(), CSSPrimitiveValue::CSS_NUMBER);
 997         case CSSPropertyWebkitMarqueeStyle:
 998             return CSSPrimitiveValue::create(style->marqueeBehavior());
 999         case CSSPropertyWebkitMaskImage:
1000             if (style->maskImage())
1001                 return style->maskImage()->cssValue();
1002             return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1003         case CSSPropertyWebkitMaskSize: {
1004             EFillSizeType size = style->maskSizeType();
1005             if (size == Contain)
1006                 return CSSPrimitiveValue::createIdentifier(CSSValueContain);
1007             if (size == Cover)
1008                 return CSSPrimitiveValue::createIdentifier(CSSValueCover);
1009             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1010             list->append(CSSPrimitiveValue::create(style->maskSizeLength().width()));
1011             list->append(CSSPrimitiveValue::create(style->maskSizeLength().height()));
1012             return list.release();
1013         }
1014         case CSSPropertyWebkitMaskRepeat:
1015             return fillRepeatToCSSValue(style->maskRepeatX(), style->maskRepeatY());
1016         case CSSPropertyWebkitMaskAttachment:
1017             return CSSPrimitiveValue::create(style->maskAttachment());
1018         case CSSPropertyWebkitMaskComposite:
1019             return CSSPrimitiveValue::create(style->maskComposite());
1020         case CSSPropertyWebkitMaskClip:
1021         case CSSPropertyWebkitMaskOrigin: {
1022             EFillBox box = (propertyID == CSSPropertyWebkitMaskClip ? style->maskClip() : style->maskOrigin());
1023             return CSSPrimitiveValue::create(box);
1024         }
1025         case CSSPropertyWebkitMaskPosition: {
1026             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1027
1028             list->append(CSSPrimitiveValue::create(style->maskXPosition()));
1029             list->append(CSSPrimitiveValue::create(style->maskYPosition()));
1030
1031             return list.release();
1032         }
1033         case CSSPropertyWebkitMaskPositionX:
1034             return CSSPrimitiveValue::create(style->maskXPosition());
1035         case CSSPropertyWebkitMaskPositionY:
1036             return CSSPrimitiveValue::create(style->maskYPosition());
1037         case CSSPropertyWebkitUserModify:
1038             return CSSPrimitiveValue::create(style->userModify());
1039         case CSSPropertyMaxHeight: {
1040             const Length& maxHeight = style->maxHeight();
1041             if (maxHeight.isFixed() && maxHeight.value() == undefinedLength)
1042                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1043             return CSSPrimitiveValue::create(maxHeight);
1044         }
1045         case CSSPropertyMaxWidth: {
1046             const Length& maxWidth = style->maxWidth();
1047             if (maxWidth.isFixed() && maxWidth.value() == undefinedLength)
1048                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1049             return CSSPrimitiveValue::create(maxWidth);
1050         }
1051         case CSSPropertyMinHeight:
1052             return CSSPrimitiveValue::create(style->minHeight());
1053         case CSSPropertyMinWidth:
1054             return CSSPrimitiveValue::create(style->minWidth());
1055         case CSSPropertyOpacity:
1056             return CSSPrimitiveValue::create(style->opacity(), CSSPrimitiveValue::CSS_NUMBER);
1057         case CSSPropertyOrphans:
1058             return CSSPrimitiveValue::create(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);
1059         case CSSPropertyOutlineColor:
1060             return m_allowVisitedStyle ? CSSPrimitiveValue::createColor(style->visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style.get(), style->outlineColor());
1061         case CSSPropertyOutlineStyle:
1062             if (style->outlineStyleIsAuto())
1063                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1064             return CSSPrimitiveValue::create(style->outlineStyle());
1065         case CSSPropertyOutlineWidth:
1066             return CSSPrimitiveValue::create(style->outlineWidth(), CSSPrimitiveValue::CSS_PX);
1067         case CSSPropertyOverflow:
1068             return CSSPrimitiveValue::create(max(style->overflowX(), style->overflowY()));
1069         case CSSPropertyOverflowX:
1070             return CSSPrimitiveValue::create(style->overflowX());
1071         case CSSPropertyOverflowY:
1072 #ifdef ANDROID_LAYOUT
1073             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
1074                 return CSSPrimitiveValue::createIdentifier(CSSValueVisible);
1075 #endif
1076             return CSSPrimitiveValue::create(style->overflowY());
1077         case CSSPropertyPaddingTop:
1078             if (renderer && renderer->isBox())
1079                 return CSSPrimitiveValue::create(toRenderBox(renderer)->paddingTop(false), CSSPrimitiveValue::CSS_PX);
1080             return CSSPrimitiveValue::create(style->paddingTop());
1081         case CSSPropertyPaddingRight:
1082             if (renderer && renderer->isBox())
1083                 return CSSPrimitiveValue::create(toRenderBox(renderer)->paddingRight(false), CSSPrimitiveValue::CSS_PX);
1084             return CSSPrimitiveValue::create(style->paddingRight());
1085         case CSSPropertyPaddingBottom:
1086             if (renderer && renderer->isBox())
1087                 return CSSPrimitiveValue::create(toRenderBox(renderer)->paddingBottom(false), CSSPrimitiveValue::CSS_PX);
1088             return CSSPrimitiveValue::create(style->paddingBottom());
1089         case CSSPropertyPaddingLeft:
1090             if (renderer && renderer->isBox())
1091                 return CSSPrimitiveValue::create(toRenderBox(renderer)->paddingLeft(false), CSSPrimitiveValue::CSS_PX);
1092             return CSSPrimitiveValue::create(style->paddingLeft());
1093         case CSSPropertyPageBreakAfter:
1094             return CSSPrimitiveValue::create(style->pageBreakAfter());
1095         case CSSPropertyPageBreakBefore:
1096             return CSSPrimitiveValue::create(style->pageBreakBefore());
1097         case CSSPropertyPageBreakInside: {
1098             EPageBreak pageBreak = style->pageBreakInside();
1099             ASSERT(pageBreak != PBALWAYS);
1100             if (pageBreak == PBALWAYS)
1101                 return 0;
1102             return CSSPrimitiveValue::create(style->pageBreakInside());
1103         }
1104         case CSSPropertyPosition:
1105 #ifdef ANDROID_LAYOUT
1106             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
1107                 return CSSPrimitiveValue::createIdentifier(CSSValueStatic);
1108 #endif
1109             return CSSPrimitiveValue::create(style->position());
1110         case CSSPropertyRight:
1111             return getPositionOffsetValue(style.get(), CSSPropertyRight);
1112         case CSSPropertyTableLayout:
1113             return CSSPrimitiveValue::create(style->tableLayout());
1114         case CSSPropertyTextAlign:
1115             return CSSPrimitiveValue::create(style->textAlign());
1116         case CSSPropertyTextDecoration:
1117             return renderTextDecorationFlagsToCSSValue(style->textDecoration());
1118         case CSSPropertyWebkitTextDecorationsInEffect:
1119             return renderTextDecorationFlagsToCSSValue(style->textDecorationsInEffect());
1120         case CSSPropertyWebkitTextFillColor:
1121             return currentColorOrValidColor(style.get(), style->textFillColor());
1122         case CSSPropertyTextIndent:
1123             return CSSPrimitiveValue::create(style->textIndent());
1124         case CSSPropertyTextShadow:
1125             return valueForShadow(style->textShadow(), propertyID);
1126         case CSSPropertyTextRendering:
1127             return CSSPrimitiveValue::create(style->fontDescription().textRenderingMode());
1128         case CSSPropertyTextOverflow:
1129             if (style->textOverflow())
1130                 return CSSPrimitiveValue::createIdentifier(CSSValueEllipsis);
1131             return CSSPrimitiveValue::createIdentifier(CSSValueClip);
1132         case CSSPropertyWebkitTextSecurity:
1133             return CSSPrimitiveValue::create(style->textSecurity());
1134         case CSSPropertyWebkitTextSizeAdjust:
1135             if (style->textSizeAdjust())
1136                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1137             return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1138         case CSSPropertyWebkitTextStrokeColor:
1139             return currentColorOrValidColor(style.get(), style->textStrokeColor());
1140         case CSSPropertyWebkitTextStrokeWidth:
1141             return CSSPrimitiveValue::create(style->textStrokeWidth(), CSSPrimitiveValue::CSS_PX);
1142         case CSSPropertyTextTransform:
1143             return CSSPrimitiveValue::create(style->textTransform());
1144         case CSSPropertyTop:
1145             return getPositionOffsetValue(style.get(), CSSPropertyTop);
1146         case CSSPropertyUnicodeBidi:
1147             return CSSPrimitiveValue::create(style->unicodeBidi());
1148         case CSSPropertyVerticalAlign:
1149             switch (style->verticalAlign()) {
1150                 case BASELINE:
1151                     return CSSPrimitiveValue::createIdentifier(CSSValueBaseline);
1152                 case MIDDLE:
1153                     return CSSPrimitiveValue::createIdentifier(CSSValueMiddle);
1154                 case SUB:
1155                     return CSSPrimitiveValue::createIdentifier(CSSValueSub);
1156                 case SUPER:
1157                     return CSSPrimitiveValue::createIdentifier(CSSValueSuper);
1158                 case TEXT_TOP:
1159                     return CSSPrimitiveValue::createIdentifier(CSSValueTextTop);
1160                 case TEXT_BOTTOM:
1161                     return CSSPrimitiveValue::createIdentifier(CSSValueTextBottom);
1162                 case TOP:
1163                     return CSSPrimitiveValue::createIdentifier(CSSValueTop);
1164                 case BOTTOM:
1165                     return CSSPrimitiveValue::createIdentifier(CSSValueBottom);
1166                 case BASELINE_MIDDLE:
1167                     return CSSPrimitiveValue::createIdentifier(CSSValueWebkitBaselineMiddle);
1168                 case LENGTH:
1169                     return CSSPrimitiveValue::create(style->verticalAlignLength());
1170             }
1171             ASSERT_NOT_REACHED();
1172             return 0;
1173         case CSSPropertyVisibility:
1174 #ifdef ANDROID_LAYOUT
1175             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
1176                 return CSSPrimitiveValue::createIdentifier(CSSValueVisible);
1177 #endif
1178             return CSSPrimitiveValue::create(style->visibility());
1179         case CSSPropertyWhiteSpace:
1180 #ifdef ANDROID_LAYOUT
1181             if (settings && settings->layoutAlgorithm() == Settings::kLayoutSSR)
1182                 switch (style->whiteSpace()) {
1183                     case NORMAL:
1184                     case NOWRAP:
1185                     case KHTML_NOWRAP:
1186                         return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
1187                     case PRE:
1188                     case PRE_WRAP:
1189                         return CSSPrimitiveValue::createIdentifier(CSSValuePreWrap);
1190                     case PRE_LINE:
1191                         return CSSPrimitiveValue::createIdentifier(CSSValuePreLine);
1192                 }
1193             else
1194 #endif
1195             return CSSPrimitiveValue::create(style->whiteSpace());
1196         case CSSPropertyWidows:
1197             return CSSPrimitiveValue::create(style->widows(), CSSPrimitiveValue::CSS_NUMBER);
1198         case CSSPropertyWidth:
1199             if (renderer)
1200                 return CSSPrimitiveValue::create(sizingBox(renderer).width(), CSSPrimitiveValue::CSS_PX);
1201             return CSSPrimitiveValue::create(style->width());
1202         case CSSPropertyWordBreak:
1203             return CSSPrimitiveValue::create(style->wordBreak());
1204         case CSSPropertyWordSpacing:
1205             return CSSPrimitiveValue::create(style->wordSpacing(), CSSPrimitiveValue::CSS_PX);
1206         case CSSPropertyWordWrap:
1207             return CSSPrimitiveValue::create(style->wordWrap());
1208         case CSSPropertyWebkitLineBreak:
1209             return CSSPrimitiveValue::create(style->khtmlLineBreak());
1210         case CSSPropertyWebkitNbspMode:
1211             return CSSPrimitiveValue::create(style->nbspMode());
1212         case CSSPropertyWebkitMatchNearestMailBlockquoteColor:
1213             return CSSPrimitiveValue::create(style->matchNearestMailBlockquoteColor());
1214         case CSSPropertyResize:
1215             return CSSPrimitiveValue::create(style->resize());
1216         case CSSPropertyWebkitFontSmoothing:
1217             return CSSPrimitiveValue::create(style->fontDescription().fontSmoothing());
1218         case CSSPropertyZIndex:
1219             if (style->hasAutoZIndex())
1220                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1221             return CSSPrimitiveValue::create(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);
1222         case CSSPropertyZoom:
1223             return CSSPrimitiveValue::create(style->zoom(), CSSPrimitiveValue::CSS_NUMBER);
1224         case CSSPropertyWebkitBoxSizing:
1225             if (style->boxSizing() == CONTENT_BOX)
1226                 return CSSPrimitiveValue::createIdentifier(CSSValueContentBox);
1227             return CSSPrimitiveValue::createIdentifier(CSSValueBorderBox);
1228 #if ENABLE(DASHBOARD_SUPPORT)
1229         case CSSPropertyWebkitDashboardRegion:
1230         {
1231             const Vector<StyleDashboardRegion>& regions = style->dashboardRegions();
1232             unsigned count = regions.size();
1233             if (count == 1 && regions[0].type == StyleDashboardRegion::None)
1234                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1235
1236             RefPtr<DashboardRegion> firstRegion;
1237             DashboardRegion* previousRegion = 0;
1238             for (unsigned i = 0; i < count; i++) {
1239                 RefPtr<DashboardRegion> region = DashboardRegion::create();
1240                 StyleDashboardRegion styleRegion = regions[i];
1241
1242                 region->m_label = styleRegion.label;
1243                 LengthBox offset = styleRegion.offset;
1244                 region->setTop(CSSPrimitiveValue::create(offset.top().value(), CSSPrimitiveValue::CSS_PX));
1245                 region->setRight(CSSPrimitiveValue::create(offset.right().value(), CSSPrimitiveValue::CSS_PX));
1246                 region->setBottom(CSSPrimitiveValue::create(offset.bottom().value(), CSSPrimitiveValue::CSS_PX));
1247                 region->setLeft(CSSPrimitiveValue::create(offset.left().value(), CSSPrimitiveValue::CSS_PX));
1248                 region->m_isRectangle = (styleRegion.type == StyleDashboardRegion::Rectangle);
1249                 region->m_isCircle = (styleRegion.type == StyleDashboardRegion::Circle);
1250
1251                 if (previousRegion)
1252                     previousRegion->m_next = region;
1253                 else
1254                     firstRegion = region;
1255                 previousRegion = region.get();
1256             }
1257             return CSSPrimitiveValue::create(firstRegion.release());
1258         }
1259 #endif
1260         case CSSPropertyWebkitAnimationDelay:
1261             return getDelayValue(style->animations());
1262         case CSSPropertyWebkitAnimationDirection: {
1263             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1264             const AnimationList* t = style->animations();
1265             if (t) {
1266                 for (size_t i = 0; i < t->size(); ++i) {
1267                     if (t->animation(i)->direction())
1268                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueAlternate));
1269                     else
1270                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueNormal));
1271                 }
1272             } else
1273                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueNormal));
1274             return list.release();
1275         }
1276         case CSSPropertyWebkitAnimationDuration:
1277             return getDurationValue(style->animations());
1278         case CSSPropertyWebkitAnimationFillMode: {
1279             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1280             const AnimationList* t = style->animations();
1281             if (t) {
1282                 for (size_t i = 0; i < t->size(); ++i) {
1283                     switch (t->animation(i)->fillMode()) {
1284                     case AnimationFillModeNone:
1285                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
1286                         break;
1287                     case AnimationFillModeForwards:
1288                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueForwards));
1289                         break;
1290                     case AnimationFillModeBackwards:
1291                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueBackwards));
1292                         break;
1293                     case AnimationFillModeBoth:
1294                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueBoth));
1295                         break;
1296                     }
1297                 }
1298             } else
1299                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
1300             return list.release();
1301         }
1302         case CSSPropertyWebkitAnimationIterationCount: {
1303             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1304             const AnimationList* t = style->animations();
1305             if (t) {
1306                 for (size_t i = 0; i < t->size(); ++i) {
1307                     int iterationCount = t->animation(i)->iterationCount();
1308                     if (iterationCount == Animation::IterationCountInfinite)
1309                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueInfinite));
1310                     else
1311                         list->append(CSSPrimitiveValue::create(iterationCount, CSSPrimitiveValue::CSS_NUMBER));
1312                 }
1313             } else
1314                 list->append(CSSPrimitiveValue::create(Animation::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
1315             return list.release();
1316         }
1317         case CSSPropertyWebkitAnimationName: {
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                     list->append(CSSPrimitiveValue::create(t->animation(i)->name(), CSSPrimitiveValue::CSS_STRING));
1323                 }
1324             } else
1325                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
1326             return list.release();
1327         }
1328         case CSSPropertyWebkitAnimationPlayState: {
1329             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1330             const AnimationList* t = style->animations();
1331             if (t) {
1332                 for (size_t i = 0; i < t->size(); ++i) {
1333                     int prop = t->animation(i)->playState();
1334                     if (prop == AnimPlayStatePlaying)
1335                         list->append(CSSPrimitiveValue::createIdentifier(CSSValueRunning));
1336                     else
1337                         list->append(CSSPrimitiveValue::createIdentifier(CSSValuePaused));
1338                 }
1339             } else
1340                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueRunning));
1341             return list.release();
1342         }
1343         case CSSPropertyWebkitAnimationTimingFunction:
1344             return getTimingFunctionValue(style->animations());
1345         case CSSPropertyWebkitAppearance:
1346             return CSSPrimitiveValue::create(style->appearance());
1347         case CSSPropertyWebkitBackfaceVisibility:
1348             return CSSPrimitiveValue::createIdentifier((style->backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
1349         case CSSPropertyWebkitBorderImage:
1350             return valueForNinePieceImage(style->borderImage());
1351         case CSSPropertyWebkitMaskBoxImage:
1352             return valueForNinePieceImage(style->maskBoxImage());
1353         case CSSPropertyWebkitFontSizeDelta:
1354             // Not a real style property -- used by the editing engine -- so has no computed value.
1355             break;
1356         case CSSPropertyWebkitMarginBottomCollapse:
1357             return CSSPrimitiveValue::create(style->marginBottomCollapse());
1358         case CSSPropertyWebkitMarginTopCollapse:
1359             return CSSPrimitiveValue::create(style->marginTopCollapse());
1360         case CSSPropertyWebkitPerspective:
1361             if (!style->hasPerspective())
1362                 return CSSPrimitiveValue::createIdentifier(CSSValueNone);
1363             return CSSPrimitiveValue::create(style->perspective(), CSSPrimitiveValue::CSS_NUMBER);
1364         case CSSPropertyWebkitPerspectiveOrigin: {
1365             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1366             if (renderer) {
1367                 IntRect box = sizingBox(renderer);
1368                 list->append(CSSPrimitiveValue::create(style->perspectiveOriginX().calcMinValue(box.width()), CSSPrimitiveValue::CSS_PX));
1369                 list->append(CSSPrimitiveValue::create(style->perspectiveOriginY().calcMinValue(box.height()), CSSPrimitiveValue::CSS_PX));
1370             }
1371             else {
1372                 list->append(CSSPrimitiveValue::create(style->perspectiveOriginX()));
1373                 list->append(CSSPrimitiveValue::create(style->perspectiveOriginY()));
1374             }
1375             return list.release();
1376         }
1377         case CSSPropertyWebkitRtlOrdering:
1378             if (style->visuallyOrdered())
1379                 return CSSPrimitiveValue::createIdentifier(CSSValueVisual);
1380             return CSSPrimitiveValue::createIdentifier(CSSValueLogical);
1381         case CSSPropertyWebkitUserDrag:
1382             return CSSPrimitiveValue::create(style->userDrag());
1383         case CSSPropertyWebkitUserSelect:
1384             return CSSPrimitiveValue::create(style->userSelect());
1385         case CSSPropertyBorderBottomLeftRadius:
1386             return getBorderRadiusCornerValue(style->borderBottomLeftRadius());
1387         case CSSPropertyBorderBottomRightRadius:
1388             return getBorderRadiusCornerValue(style->borderBottomRightRadius());
1389         case CSSPropertyBorderTopLeftRadius:
1390             return getBorderRadiusCornerValue(style->borderTopLeftRadius());
1391         case CSSPropertyBorderTopRightRadius:
1392             return getBorderRadiusCornerValue(style->borderTopRightRadius());
1393         case CSSPropertyClip: {
1394             if (!style->hasClip())
1395                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1396             RefPtr<Rect> rect = Rect::create();
1397             rect->setTop(CSSPrimitiveValue::create(style->clip().top().value(), CSSPrimitiveValue::CSS_PX));
1398             rect->setRight(CSSPrimitiveValue::create(style->clip().right().value(), CSSPrimitiveValue::CSS_PX));
1399             rect->setBottom(CSSPrimitiveValue::create(style->clip().bottom().value(), CSSPrimitiveValue::CSS_PX));
1400             rect->setLeft(CSSPrimitiveValue::create(style->clip().left().value(), CSSPrimitiveValue::CSS_PX));
1401             return CSSPrimitiveValue::create(rect.release());
1402         }
1403         case CSSPropertyWebkitTransform:
1404             return computedTransform(renderer, style.get());
1405         case CSSPropertyWebkitTransformOrigin: {
1406             RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1407             if (renderer) {
1408                 IntRect box = sizingBox(renderer);
1409                 list->append(CSSPrimitiveValue::create(style->transformOriginX().calcMinValue(box.width()), CSSPrimitiveValue::CSS_PX));
1410                 list->append(CSSPrimitiveValue::create(style->transformOriginY().calcMinValue(box.height()), CSSPrimitiveValue::CSS_PX));
1411                 if (style->transformOriginZ() != 0)
1412                     list->append(CSSPrimitiveValue::create(style->transformOriginZ(), CSSPrimitiveValue::CSS_PX));
1413             } else {
1414                 list->append(CSSPrimitiveValue::create(style->transformOriginX()));
1415                 list->append(CSSPrimitiveValue::create(style->transformOriginY()));
1416                 if (style->transformOriginZ() != 0)
1417                     list->append(CSSPrimitiveValue::create(style->transformOriginZ(), CSSPrimitiveValue::CSS_PX));
1418             }
1419             return list.release();
1420         }
1421         case CSSPropertyWebkitTransformStyle:
1422             return CSSPrimitiveValue::createIdentifier((style->transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
1423         case CSSPropertyWebkitTransitionDelay:
1424             return getDelayValue(style->transitions());
1425         case CSSPropertyWebkitTransitionDuration:
1426             return getDurationValue(style->transitions());
1427         case CSSPropertyWebkitTransitionProperty: {
1428             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1429             const AnimationList* t = style->transitions();
1430             if (t) {
1431                 for (size_t i = 0; i < t->size(); ++i) {
1432                     int prop = t->animation(i)->property();
1433                     RefPtr<CSSValue> propertyValue;
1434                     if (prop == cAnimateNone)
1435                         propertyValue = CSSPrimitiveValue::createIdentifier(CSSValueNone);
1436                     else if (prop == cAnimateAll)
1437                         propertyValue = CSSPrimitiveValue::createIdentifier(CSSValueAll);
1438                     else
1439                         propertyValue = CSSPrimitiveValue::create(getPropertyName(static_cast<CSSPropertyID>(prop)), CSSPrimitiveValue::CSS_STRING);
1440                     list->append(propertyValue);
1441                 }
1442             } else
1443                 list->append(CSSPrimitiveValue::createIdentifier(CSSValueAll));
1444             return list.release();
1445         }
1446         case CSSPropertyWebkitTransitionTimingFunction:
1447             return getTimingFunctionValue(style->transitions());
1448         case CSSPropertyPointerEvents:
1449             return CSSPrimitiveValue::create(style->pointerEvents());
1450         case CSSPropertyWebkitColorCorrection:
1451             return CSSPrimitiveValue::create(style->colorSpace());
1452
1453         /* Shorthand properties, currently not supported see bug 13658*/
1454         case CSSPropertyBackground:
1455         case CSSPropertyBorder:
1456         case CSSPropertyBorderBottom:
1457         case CSSPropertyBorderColor:
1458         case CSSPropertyBorderLeft:
1459         case CSSPropertyBorderRadius:
1460         case CSSPropertyBorderRight:
1461         case CSSPropertyBorderStyle:
1462         case CSSPropertyBorderTop:
1463         case CSSPropertyBorderWidth:
1464         case CSSPropertyFont:
1465         case CSSPropertyListStyle:
1466         case CSSPropertyMargin:
1467         case CSSPropertyPadding:
1468             break;
1469
1470         /* Unimplemented CSS 3 properties (including CSS3 shorthand properties) */
1471         case CSSPropertyTextLineThrough:
1472         case CSSPropertyTextLineThroughColor:
1473         case CSSPropertyTextLineThroughMode:
1474         case CSSPropertyTextLineThroughStyle:
1475         case CSSPropertyTextLineThroughWidth:
1476         case CSSPropertyTextOverline:
1477         case CSSPropertyTextOverlineColor:
1478         case CSSPropertyTextOverlineMode:
1479         case CSSPropertyTextOverlineStyle:
1480         case CSSPropertyTextOverlineWidth:
1481         case CSSPropertyTextUnderline:
1482         case CSSPropertyTextUnderlineColor:
1483         case CSSPropertyTextUnderlineMode:
1484         case CSSPropertyTextUnderlineStyle:
1485         case CSSPropertyTextUnderlineWidth:
1486             break;
1487
1488         /* Directional properties are resolved by resolveDirectionAwareProperty() before the switch. */
1489         case CSSPropertyWebkitBorderEnd:
1490         case CSSPropertyWebkitBorderEndColor:
1491         case CSSPropertyWebkitBorderEndStyle:
1492         case CSSPropertyWebkitBorderEndWidth:
1493         case CSSPropertyWebkitBorderStart:
1494         case CSSPropertyWebkitBorderStartColor:
1495         case CSSPropertyWebkitBorderStartStyle:
1496         case CSSPropertyWebkitBorderStartWidth:
1497         case CSSPropertyWebkitMarginEnd:
1498         case CSSPropertyWebkitMarginStart:
1499         case CSSPropertyWebkitPaddingEnd:
1500         case CSSPropertyWebkitPaddingStart:
1501             ASSERT_NOT_REACHED();
1502             break;
1503
1504         /* Unimplemented @font-face properties */
1505         case CSSPropertyFontStretch:
1506         case CSSPropertySrc:
1507         case CSSPropertyUnicodeRange:
1508             break;
1509
1510         /* Other unimplemented properties */
1511         case CSSPropertyBackgroundRepeatX:
1512         case CSSPropertyBackgroundRepeatY:
1513         case CSSPropertyContent: // FIXME: needs implementation, bug 23668
1514         case CSSPropertyCounterIncrement:
1515         case CSSPropertyCounterReset:
1516         case CSSPropertyOutline: // FIXME: needs implementation
1517         case CSSPropertyOutlineOffset: // FIXME: needs implementation
1518         case CSSPropertyPage: // for @page
1519         case CSSPropertyQuotes: // FIXME: needs implementation
1520         case CSSPropertySize: // for @page
1521             break;
1522
1523         /* Unimplemented -webkit- properties */
1524         case CSSPropertyWebkitAnimation:
1525         case CSSPropertyWebkitBorderRadius:
1526         case CSSPropertyWebkitColumns:
1527         case CSSPropertyWebkitColumnRule:
1528         case CSSPropertyWebkitMarginCollapse:
1529         case CSSPropertyWebkitMarquee:
1530         case CSSPropertyWebkitMarqueeSpeed:
1531         case CSSPropertyWebkitMask:
1532         case CSSPropertyWebkitMaskRepeatX:
1533         case CSSPropertyWebkitMaskRepeatY:
1534         case CSSPropertyWebkitPerspectiveOriginX:
1535         case CSSPropertyWebkitPerspectiveOriginY:
1536         case CSSPropertyWebkitTextStroke:
1537         case CSSPropertyWebkitTransformOriginX:
1538         case CSSPropertyWebkitTransformOriginY:
1539         case CSSPropertyWebkitTransformOriginZ:
1540         case CSSPropertyWebkitTransition:
1541         case CSSPropertyWebkitVariableDeclarationBlock:
1542             break;
1543 #ifdef ANDROID_CSS_TAP_HIGHLIGHT_COLOR
1544         case CSSPropertyWebkitTapHighlightColor:
1545             return CSSPrimitiveValue::createColor(style->tapHighlightColor().rgb());
1546 #endif
1547 #if ENABLE(SVG)
1548         // FIXME: This default case ruins the point of using an enum for
1549         // properties -- it prevents us from getting a warning when we
1550         // forget to list a property above.
1551         default:
1552             return getSVGPropertyCSSValue(propertyID, DoNotUpdateLayout);
1553 #endif
1554     }
1555
1556     logUnimplementedPropertyID(propertyID);
1557     return 0;
1558 }
1559
1560 String CSSComputedStyleDeclaration::getPropertyValue(int propertyID) const
1561 {
1562     RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);
1563     if (value)
1564         return value->cssText();
1565     return "";
1566 }
1567
1568 bool CSSComputedStyleDeclaration::getPropertyPriority(int /*propertyID*/) const
1569 {
1570     // All computed styles have a priority of false (not "important").
1571     return false;
1572 }
1573
1574 String CSSComputedStyleDeclaration::removeProperty(int /*propertyID*/, ExceptionCode& ec)
1575 {
1576     ec = NO_MODIFICATION_ALLOWED_ERR;
1577     return String();
1578 }
1579
1580 void CSSComputedStyleDeclaration::setProperty(int /*propertyID*/, const String& /*value*/, bool /*important*/, ExceptionCode& ec)
1581 {
1582     ec = NO_MODIFICATION_ALLOWED_ERR;
1583 }
1584
1585 unsigned CSSComputedStyleDeclaration::virtualLength() const
1586 {
1587     Node* node = m_node.get();
1588     if (!node)
1589         return 0;
1590
1591     RenderStyle* style = node->computedStyle(m_pseudoElementSpecifier);
1592     if (!style)
1593         return 0;
1594
1595     return numComputedProperties;
1596 }
1597
1598 String CSSComputedStyleDeclaration::item(unsigned i) const
1599 {
1600     if (i >= length())
1601         return "";
1602
1603     return getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));
1604 }
1605
1606 bool CSSComputedStyleDeclaration::cssPropertyMatches(const CSSProperty* property) const
1607 {
1608     if (property->id() == CSSPropertyFontSize && property->value()->isPrimitiveValue() && m_node) {
1609         m_node->document()->updateLayoutIgnorePendingStylesheets();
1610         RenderStyle* style = m_node->computedStyle(m_pseudoElementSpecifier);
1611         if (style && style->fontDescription().keywordSize()) {
1612             int sizeValue = cssIdentifierForFontSizeKeyword(style->fontDescription().keywordSize());
1613             CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(property->value());
1614             if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_IDENT && primitiveValue->getIdent() == sizeValue)
1615                 return true;
1616         }
1617     }
1618
1619     return CSSStyleDeclaration::cssPropertyMatches(property);
1620 }
1621
1622 PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::copy() const
1623 {
1624     return copyPropertiesInSet(computedProperties, numComputedProperties);
1625 }
1626
1627 PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::makeMutable()
1628 {
1629     return copy();
1630 }
1631
1632 } // namespace WebCore