WebCore/css/CSSComputedStyleDeclaration.cpp

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