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