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