1 /*
2 * Copyright (C) 2004 Zack Rusin <zack@kde.org>
3 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
4 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
5 * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
6 * Copyright (C) 2011 Sencha, Inc. All rights reserved.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 * 02110-1301 USA
22 */
23
24 #include "config.h"
25 #include "CSSComputedStyleDeclaration.h"
26
27 #include "AnimationController.h"
28 #include "ContentData.h"
29 #include "CounterContent.h"
30 #include "CursorList.h"
31 #include "CSSBorderImageValue.h"
32 #include "CSSLineBoxContainValue.h"
33 #include "CSSMutableStyleDeclaration.h"
34 #include "CSSPrimitiveValue.h"
35 #include "CSSPrimitiveValueCache.h"
36 #include "CSSPrimitiveValueMappings.h"
37 #include "CSSProperty.h"
38 #include "CSSPropertyNames.h"
39 #include "CSSReflectValue.h"
40 #include "CSSSelector.h"
41 #include "CSSTimingFunctionValue.h"
42 #include "CSSValueList.h"
43 #include "Document.h"
44 #include "ExceptionCode.h"
45 #include "Rect.h"
46 #include "RenderBox.h"
47 #include "RenderLayer.h"
48 #include "ShadowValue.h"
49 #include "WebKitCSSTransformValue.h"
50
51 #if ENABLE(DASHBOARD_SUPPORT)
52 #include "DashboardRegion.h"
53 #endif
54
55 namespace WebCore {
56
57 // List of all properties we know how to compute, omitting shorthands.
58 static const int computedProperties[] = {
59 CSSPropertyBackgroundAttachment,
60 CSSPropertyBackgroundClip,
61 CSSPropertyBackgroundColor,
62 CSSPropertyBackgroundImage,
63 CSSPropertyBackgroundOrigin,
64 CSSPropertyBackgroundPosition, // more-specific background-position-x/y are non-standard
65 CSSPropertyBackgroundRepeat,
66 CSSPropertyBackgroundSize,
67 CSSPropertyBorderBottomColor,
68 CSSPropertyBorderBottomLeftRadius,
69 CSSPropertyBorderBottomRightRadius,
70 CSSPropertyBorderBottomStyle,
71 CSSPropertyBorderBottomWidth,
72 CSSPropertyBorderCollapse,
73 CSSPropertyBorderLeftColor,
74 CSSPropertyBorderLeftStyle,
75 CSSPropertyBorderLeftWidth,
76 CSSPropertyBorderRightColor,
77 CSSPropertyBorderRightStyle,
78 CSSPropertyBorderRightWidth,
79 CSSPropertyBorderTopColor,
80 CSSPropertyBorderTopLeftRadius,
81 CSSPropertyBorderTopRightRadius,
82 CSSPropertyBorderTopStyle,
83 CSSPropertyBorderTopWidth,
84 CSSPropertyBottom,
85 CSSPropertyBoxShadow,
86 CSSPropertyBoxSizing,
87 CSSPropertyCaptionSide,
88 CSSPropertyClear,
89 CSSPropertyClip,
90 CSSPropertyColor,
91 CSSPropertyCursor,
92 CSSPropertyDirection,
93 CSSPropertyDisplay,
94 CSSPropertyEmptyCells,
95 CSSPropertyFloat,
96 CSSPropertyFontFamily,
97 CSSPropertyFontSize,
98 CSSPropertyFontStyle,
99 CSSPropertyFontVariant,
100 CSSPropertyFontWeight,
101 CSSPropertyHeight,
102 CSSPropertyLeft,
103 CSSPropertyLetterSpacing,
104 CSSPropertyLineHeight,
105 CSSPropertyListStyleImage,
106 CSSPropertyListStylePosition,
107 CSSPropertyListStyleType,
108 CSSPropertyMarginBottom,
109 CSSPropertyMarginLeft,
110 CSSPropertyMarginRight,
111 CSSPropertyMarginTop,
112 CSSPropertyMaxHeight,
113 CSSPropertyMaxWidth,
114 CSSPropertyMinHeight,
115 CSSPropertyMinWidth,
116 CSSPropertyOpacity,
117 CSSPropertyOrphans,
118 CSSPropertyOutlineColor,
119 CSSPropertyOutlineStyle,
120 CSSPropertyOutlineWidth,
121 CSSPropertyOverflowX,
122 CSSPropertyOverflowY,
123 CSSPropertyPaddingBottom,
124 CSSPropertyPaddingLeft,
125 CSSPropertyPaddingRight,
126 CSSPropertyPaddingTop,
127 CSSPropertyPageBreakAfter,
128 CSSPropertyPageBreakBefore,
129 CSSPropertyPageBreakInside,
130 CSSPropertyPointerEvents,
131 CSSPropertyPosition,
132 CSSPropertyResize,
133 CSSPropertyRight,
134 CSSPropertySpeak,
135 CSSPropertyTableLayout,
136 CSSPropertyTextAlign,
137 CSSPropertyTextDecoration,
138 CSSPropertyTextIndent,
139 CSSPropertyTextRendering,
140 CSSPropertyTextShadow,
141 CSSPropertyTextOverflow,
142 CSSPropertyTextTransform,
143 CSSPropertyTop,
144 CSSPropertyUnicodeBidi,
145 CSSPropertyVerticalAlign,
146 CSSPropertyVisibility,
147 CSSPropertyWhiteSpace,
148 CSSPropertyWidows,
149 CSSPropertyWidth,
150 CSSPropertyWordBreak,
151 CSSPropertyWordSpacing,
152 CSSPropertyWordWrap,
153 CSSPropertyZIndex,
154 CSSPropertyZoom,
155
156 CSSPropertyWebkitAnimationDelay,
157 CSSPropertyWebkitAnimationDirection,
158 CSSPropertyWebkitAnimationDuration,
159 CSSPropertyWebkitAnimationFillMode,
160 CSSPropertyWebkitAnimationIterationCount,
161 CSSPropertyWebkitAnimationName,
162 CSSPropertyWebkitAnimationPlayState,
163 CSSPropertyWebkitAnimationTimingFunction,
164 CSSPropertyWebkitAppearance,
165 CSSPropertyWebkitBackfaceVisibility,
166 CSSPropertyWebkitBackgroundClip,
167 CSSPropertyWebkitBackgroundComposite,
168 CSSPropertyWebkitBackgroundOrigin,
169 CSSPropertyWebkitBackgroundSize,
170 CSSPropertyWebkitBorderFit,
171 CSSPropertyWebkitBorderHorizontalSpacing,
172 CSSPropertyWebkitBorderImage,
173 CSSPropertyWebkitBorderVerticalSpacing,
174 CSSPropertyWebkitBoxAlign,
175 CSSPropertyWebkitBoxDirection,
176 CSSPropertyWebkitBoxFlex,
177 CSSPropertyWebkitBoxFlexGroup,
178 CSSPropertyWebkitBoxLines,
179 CSSPropertyWebkitBoxOrdinalGroup,
180 CSSPropertyWebkitBoxOrient,
181 CSSPropertyWebkitBoxPack,
182 CSSPropertyWebkitBoxReflect,
183 CSSPropertyWebkitBoxShadow,
184 CSSPropertyWebkitColorCorrection,
185 CSSPropertyWebkitColumnBreakAfter,
186 CSSPropertyWebkitColumnBreakBefore,
187 CSSPropertyWebkitColumnBreakInside,
188 CSSPropertyWebkitColumnCount,
189 CSSPropertyWebkitColumnGap,
190 CSSPropertyWebkitColumnRuleColor,
191 CSSPropertyWebkitColumnRuleStyle,
192 CSSPropertyWebkitColumnRuleWidth,
193 CSSPropertyWebkitColumnSpan,
194 CSSPropertyWebkitColumnWidth,
195 #if ENABLE(DASHBOARD_SUPPORT)
196 CSSPropertyWebkitDashboardRegion,
197 #endif
198 CSSPropertyWebkitFontSmoothing,
199 CSSPropertyWebkitHighlight,
200 CSSPropertyWebkitHyphenateCharacter,
201 CSSPropertyWebkitHyphenateLimitAfter,
202 CSSPropertyWebkitHyphenateLimitBefore,
203 CSSPropertyWebkitHyphens,
204 CSSPropertyWebkitLineBoxContain,
205 CSSPropertyWebkitLineBreak,
206 CSSPropertyWebkitLineClamp,
207 CSSPropertyWebkitLocale,
208 CSSPropertyWebkitMarginBeforeCollapse,
209 CSSPropertyWebkitMarginAfterCollapse,
210 CSSPropertyWebkitMarqueeDirection,
211 CSSPropertyWebkitMarqueeIncrement,
212 CSSPropertyWebkitMarqueeRepetition,
213 CSSPropertyWebkitMarqueeStyle,
214 CSSPropertyWebkitMaskAttachment,
215 CSSPropertyWebkitMaskBoxImage,
216 CSSPropertyWebkitMaskClip,
217 CSSPropertyWebkitMaskComposite,
218 CSSPropertyWebkitMaskImage,
219 CSSPropertyWebkitMaskOrigin,
220 CSSPropertyWebkitMaskPosition,
221 CSSPropertyWebkitMaskRepeat,
222 CSSPropertyWebkitMaskSize,
223 CSSPropertyWebkitNbspMode,
224 CSSPropertyWebkitPerspective,
225 CSSPropertyWebkitPerspectiveOrigin,
226 CSSPropertyWebkitRtlOrdering,
227 CSSPropertyWebkitTextCombine,
228 CSSPropertyWebkitTextDecorationsInEffect,
229 CSSPropertyWebkitTextEmphasisColor,
230 CSSPropertyWebkitTextEmphasisPosition,
231 CSSPropertyWebkitTextEmphasisStyle,
232 CSSPropertyWebkitTextFillColor,
233 CSSPropertyWebkitTextOrientation,
234 CSSPropertyWebkitTextSecurity,
235 CSSPropertyWebkitTextStrokeColor,
236 CSSPropertyWebkitTextStrokeWidth,
237 CSSPropertyWebkitTransform,
238 CSSPropertyWebkitTransformOrigin,
239 CSSPropertyWebkitTransformStyle,
240 CSSPropertyWebkitTransitionDelay,
241 CSSPropertyWebkitTransitionDuration,
242 CSSPropertyWebkitTransitionProperty,
243 CSSPropertyWebkitTransitionTimingFunction,
244 CSSPropertyWebkitUserDrag,
245 CSSPropertyWebkitUserModify,
246 CSSPropertyWebkitUserSelect,
247 CSSPropertyWebkitWritingMode
248
249 #if ENABLE(SVG)
250 ,
251 CSSPropertyClipPath,
252 CSSPropertyClipRule,
253 CSSPropertyMask,
254 CSSPropertyFilter,
255 CSSPropertyFloodColor,
256 CSSPropertyFloodOpacity,
257 CSSPropertyLightingColor,
258 CSSPropertyStopColor,
259 CSSPropertyStopOpacity,
260 CSSPropertyColorInterpolation,
261 CSSPropertyColorInterpolationFilters,
262 CSSPropertyColorRendering,
263 CSSPropertyFill,
264 CSSPropertyFillOpacity,
265 CSSPropertyFillRule,
266 CSSPropertyImageRendering,
267 CSSPropertyMarkerEnd,
268 CSSPropertyMarkerMid,
269 CSSPropertyMarkerStart,
270 CSSPropertyShapeRendering,
271 CSSPropertyStroke,
272 CSSPropertyStrokeDasharray,
273 CSSPropertyStrokeDashoffset,
274 CSSPropertyStrokeLinecap,
275 CSSPropertyStrokeLinejoin,
276 CSSPropertyStrokeMiterlimit,
277 CSSPropertyStrokeOpacity,
278 CSSPropertyStrokeWidth,
279 CSSPropertyAlignmentBaseline,
280 CSSPropertyBaselineShift,
281 CSSPropertyDominantBaseline,
282 CSSPropertyKerning,
283 CSSPropertyTextAnchor,
284 CSSPropertyWritingMode,
285 CSSPropertyGlyphOrientationHorizontal,
286 CSSPropertyGlyphOrientationVertical,
287 CSSPropertyWebkitSvgShadow,
288 CSSPropertyVectorEffect
289 #endif
290 };
291
292 const unsigned numComputedProperties = WTF_ARRAY_LENGTH(computedProperties);
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,CSSPrimitiveValueCache * primitiveValueCache)306 static PassRefPtr<CSSValue> valueForNinePieceImage(const NinePieceImage& image, CSSPrimitiveValueCache* primitiveValueCache)
307 {
308 if (!image.hasImage())
309 return primitiveValueCache->createIdentifierValue(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.slices().top().isPercent())
319 top = primitiveValueCache->createValue(image.slices().top().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
320 else
321 top = primitiveValueCache->createValue(image.slices().top().value(), CSSPrimitiveValue::CSS_NUMBER);
322
323 RefPtr<CSSPrimitiveValue> right;
324 if (image.slices().right().isPercent())
325 right = primitiveValueCache->createValue(image.slices().right().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
326 else
327 right = primitiveValueCache->createValue(image.slices().right().value(), CSSPrimitiveValue::CSS_NUMBER);
328
329 RefPtr<CSSPrimitiveValue> bottom;
330 if (image.slices().bottom().isPercent())
331 bottom = primitiveValueCache->createValue(image.slices().bottom().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
332 else
333 bottom = primitiveValueCache->createValue(image.slices().bottom().value(), CSSPrimitiveValue::CSS_NUMBER);
334
335 RefPtr<CSSPrimitiveValue> left;
336 if (image.slices().left().isPercent())
337 left = primitiveValueCache->createValue(image.slices().left().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
338 else
339 left = primitiveValueCache->createValue(image.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.horizontalRule()), valueForRepeatRule(image.verticalRule()));
348 }
349
zoomAdjustedPixelValue(int value,const RenderStyle * style,CSSPrimitiveValueCache * primitiveValueCache)350 inline static PassRefPtr<CSSPrimitiveValue> zoomAdjustedPixelValue(int value, const RenderStyle* style, CSSPrimitiveValueCache* primitiveValueCache)
351 {
352 return primitiveValueCache->createValue(adjustForAbsoluteZoom(value, style), CSSPrimitiveValue::CSS_PX);
353 }
354
zoomAdjustedNumberValue(double value,const RenderStyle * style,CSSPrimitiveValueCache * primitiveValueCache)355 inline static PassRefPtr<CSSPrimitiveValue> zoomAdjustedNumberValue(double value, const RenderStyle* style, CSSPrimitiveValueCache* primitiveValueCache)
356 {
357 return primitiveValueCache->createValue(value / style->effectiveZoom(), CSSPrimitiveValue::CSS_NUMBER);
358 }
359
zoomAdjustedPixelValueForLength(const Length & length,const RenderStyle * style,CSSPrimitiveValueCache * primitiveValueCache)360 static PassRefPtr<CSSValue> zoomAdjustedPixelValueForLength(const Length& length, const RenderStyle* style, CSSPrimitiveValueCache* primitiveValueCache)
361 {
362 if (length.isFixed())
363 return zoomAdjustedPixelValue(length.value(), style, primitiveValueCache);
364 return primitiveValueCache->createValue(length);
365 }
366
valueForReflection(const StyleReflection * reflection,const RenderStyle * style,CSSPrimitiveValueCache * primitiveValueCache)367 static PassRefPtr<CSSValue> valueForReflection(const StyleReflection* reflection, const RenderStyle* style, CSSPrimitiveValueCache* primitiveValueCache)
368 {
369 if (!reflection)
370 return primitiveValueCache->createIdentifierValue(CSSValueNone);
371
372 RefPtr<CSSPrimitiveValue> offset;
373 if (reflection->offset().isPercent())
374 offset = primitiveValueCache->createValue(reflection->offset().percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
375 else
376 offset = zoomAdjustedPixelValue(reflection->offset().value(), style, primitiveValueCache);
377
378 return CSSReflectValue::create(reflection->direction(), offset.release(), valueForNinePieceImage(reflection->mask(), primitiveValueCache));
379 }
380
getPositionOffsetValue(RenderStyle * style,int propertyID,CSSPrimitiveValueCache * primitiveValueCache)381 static PassRefPtr<CSSValue> getPositionOffsetValue(RenderStyle* style, int propertyID, CSSPrimitiveValueCache* primitiveValueCache)
382 {
383 if (!style)
384 return 0;
385
386 Length l;
387 switch (propertyID) {
388 case CSSPropertyLeft:
389 l = style->left();
390 break;
391 case CSSPropertyRight:
392 l = style->right();
393 break;
394 case CSSPropertyTop:
395 l = style->top();
396 break;
397 case CSSPropertyBottom:
398 l = style->bottom();
399 break;
400 default:
401 return 0;
402 }
403
404 if (style->position() == AbsolutePosition || style->position() == FixedPosition) {
405 if (l.type() == WebCore::Fixed)
406 return zoomAdjustedPixelValue(l.value(), style, primitiveValueCache);
407 return primitiveValueCache->createValue(l);
408 }
409
410 if (style->position() == RelativePosition)
411 // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
412 // In other words if left is auto and right is not auto, then left's computed value is negative right().
413 // So we should get the opposite length unit and see if it is auto.
414 return primitiveValueCache->createValue(l);
415
416 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
417 }
418
currentColorOrValidColor(RenderStyle * style,const Color & color) const419 PassRefPtr<CSSPrimitiveValue> CSSComputedStyleDeclaration::currentColorOrValidColor(RenderStyle* style, const Color& color) const
420 {
421 // This function does NOT look at visited information, so that computed style doesn't expose that.
422 CSSPrimitiveValueCache* primitiveValueCache = m_node->document()->cssPrimitiveValueCache().get();
423 if (!color.isValid())
424 return primitiveValueCache->createColorValue(style->color().rgb());
425 return primitiveValueCache->createColorValue(color.rgb());
426 }
427
getBorderRadiusCornerValue(LengthSize radius,const RenderStyle * style,CSSPrimitiveValueCache * primitiveValueCache)428 static PassRefPtr<CSSValue> getBorderRadiusCornerValue(LengthSize radius, const RenderStyle* style, CSSPrimitiveValueCache* primitiveValueCache)
429 {
430 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
431 if (radius.width() == radius.height()) {
432 if (radius.width().type() == Percent)
433 return primitiveValueCache->createValue(radius.width().percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
434 return zoomAdjustedPixelValue(radius.width().value(), style, primitiveValueCache);
435 }
436 if (radius.width().type() == Percent)
437 list->append(primitiveValueCache->createValue(radius.width().percent(), CSSPrimitiveValue::CSS_PERCENTAGE));
438 else
439 list->append(zoomAdjustedPixelValue(radius.width().value(), style, primitiveValueCache));
440 if (radius.height().type() == Percent)
441 list->append(primitiveValueCache->createValue(radius.height().percent(), CSSPrimitiveValue::CSS_PERCENTAGE));
442 else
443 list->append(zoomAdjustedPixelValue(radius.height().value(), style, primitiveValueCache));
444 return list.release();
445 }
446
sizingBox(RenderObject * renderer)447 static IntRect sizingBox(RenderObject* renderer)
448 {
449 if (!renderer->isBox())
450 return IntRect();
451
452 RenderBox* box = toRenderBox(renderer);
453 return box->style()->boxSizing() == CONTENT_BOX ? box->contentBoxRect() : box->borderBoxRect();
454 }
455
hasCompositedLayer(RenderObject * renderer)456 static inline bool hasCompositedLayer(RenderObject* renderer)
457 {
458 return renderer && renderer->hasLayer() && toRenderBoxModelObject(renderer)->layer()->isComposited();
459 }
460
computedTransform(RenderObject * renderer,const RenderStyle * style,CSSPrimitiveValueCache * primitiveValueCache)461 static PassRefPtr<CSSValue> computedTransform(RenderObject* renderer, const RenderStyle* style, CSSPrimitiveValueCache* primitiveValueCache)
462 {
463 if (!renderer || style->transform().operations().isEmpty())
464 return primitiveValueCache->createIdentifierValue(CSSValueNone);
465
466 IntRect box = sizingBox(renderer);
467
468 TransformationMatrix transform;
469 style->applyTransform(transform, box.size(), RenderStyle::ExcludeTransformOrigin);
470 // Note that this does not flatten to an affine transform if ENABLE(3D_RENDERING) is off, by design.
471
472 RefPtr<WebKitCSSTransformValue> transformVal;
473
474 // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
475 if (transform.isAffine()) {
476 transformVal = WebKitCSSTransformValue::create(WebKitCSSTransformValue::MatrixTransformOperation);
477
478 transformVal->append(primitiveValueCache->createValue(transform.a(), CSSPrimitiveValue::CSS_NUMBER));
479 transformVal->append(primitiveValueCache->createValue(transform.b(), CSSPrimitiveValue::CSS_NUMBER));
480 transformVal->append(primitiveValueCache->createValue(transform.c(), CSSPrimitiveValue::CSS_NUMBER));
481 transformVal->append(primitiveValueCache->createValue(transform.d(), CSSPrimitiveValue::CSS_NUMBER));
482 transformVal->append(zoomAdjustedNumberValue(transform.e(), style, primitiveValueCache));
483 transformVal->append(zoomAdjustedNumberValue(transform.f(), style, primitiveValueCache));
484 } else {
485 transformVal = WebKitCSSTransformValue::create(WebKitCSSTransformValue::Matrix3DTransformOperation);
486
487 transformVal->append(primitiveValueCache->createValue(transform.m11(), CSSPrimitiveValue::CSS_NUMBER));
488 transformVal->append(primitiveValueCache->createValue(transform.m12(), CSSPrimitiveValue::CSS_NUMBER));
489 transformVal->append(primitiveValueCache->createValue(transform.m13(), CSSPrimitiveValue::CSS_NUMBER));
490 transformVal->append(primitiveValueCache->createValue(transform.m14(), CSSPrimitiveValue::CSS_NUMBER));
491
492 transformVal->append(primitiveValueCache->createValue(transform.m21(), CSSPrimitiveValue::CSS_NUMBER));
493 transformVal->append(primitiveValueCache->createValue(transform.m22(), CSSPrimitiveValue::CSS_NUMBER));
494 transformVal->append(primitiveValueCache->createValue(transform.m23(), CSSPrimitiveValue::CSS_NUMBER));
495 transformVal->append(primitiveValueCache->createValue(transform.m24(), CSSPrimitiveValue::CSS_NUMBER));
496
497 transformVal->append(primitiveValueCache->createValue(transform.m31(), CSSPrimitiveValue::CSS_NUMBER));
498 transformVal->append(primitiveValueCache->createValue(transform.m32(), CSSPrimitiveValue::CSS_NUMBER));
499 transformVal->append(primitiveValueCache->createValue(transform.m33(), CSSPrimitiveValue::CSS_NUMBER));
500 transformVal->append(primitiveValueCache->createValue(transform.m34(), CSSPrimitiveValue::CSS_NUMBER));
501
502 transformVal->append(zoomAdjustedNumberValue(transform.m41(), style, primitiveValueCache));
503 transformVal->append(zoomAdjustedNumberValue(transform.m42(), style, primitiveValueCache));
504 transformVal->append(zoomAdjustedNumberValue(transform.m43(), style, primitiveValueCache));
505 transformVal->append(primitiveValueCache->createValue(transform.m44(), CSSPrimitiveValue::CSS_NUMBER));
506 }
507
508 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
509 list->append(transformVal);
510
511 return list.release();
512 }
513
getDelayValue(const AnimationList * animList,CSSPrimitiveValueCache * primitiveValueCache)514 static PassRefPtr<CSSValue> getDelayValue(const AnimationList* animList, CSSPrimitiveValueCache* primitiveValueCache)
515 {
516 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
517 if (animList) {
518 for (size_t i = 0; i < animList->size(); ++i)
519 list->append(primitiveValueCache->createValue(animList->animation(i)->delay(), CSSPrimitiveValue::CSS_S));
520 } else {
521 // Note that initialAnimationDelay() is used for both transitions and animations
522 list->append(primitiveValueCache->createValue(Animation::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
523 }
524 return list.release();
525 }
526
getDurationValue(const AnimationList * animList,CSSPrimitiveValueCache * primitiveValueCache)527 static PassRefPtr<CSSValue> getDurationValue(const AnimationList* animList, CSSPrimitiveValueCache* primitiveValueCache)
528 {
529 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
530 if (animList) {
531 for (size_t i = 0; i < animList->size(); ++i)
532 list->append(primitiveValueCache->createValue(animList->animation(i)->duration(), CSSPrimitiveValue::CSS_S));
533 } else {
534 // Note that initialAnimationDuration() is used for both transitions and animations
535 list->append(primitiveValueCache->createValue(Animation::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
536 }
537 return list.release();
538 }
539
getTimingFunctionValue(const AnimationList * animList)540 static PassRefPtr<CSSValue> getTimingFunctionValue(const AnimationList* animList)
541 {
542 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
543 if (animList) {
544 for (size_t i = 0; i < animList->size(); ++i) {
545 const TimingFunction* tf = animList->animation(i)->timingFunction().get();
546 if (tf->isCubicBezierTimingFunction()) {
547 const CubicBezierTimingFunction* ctf = static_cast<const CubicBezierTimingFunction*>(tf);
548 list->append(CSSCubicBezierTimingFunctionValue::create(ctf->x1(), ctf->y1(), ctf->x2(), ctf->y2()));
549 } else if (tf->isStepsTimingFunction()) {
550 const StepsTimingFunction* stf = static_cast<const StepsTimingFunction*>(tf);
551 list->append(CSSStepsTimingFunctionValue::create(stf->numberOfSteps(), stf->stepAtStart()));
552 } else {
553 list->append(CSSLinearTimingFunctionValue::create());
554 }
555 }
556 } else {
557 // Note that initialAnimationTimingFunction() is used for both transitions and animations
558 RefPtr<TimingFunction> tf = Animation::initialAnimationTimingFunction();
559 if (tf->isCubicBezierTimingFunction()) {
560 const CubicBezierTimingFunction* ctf = static_cast<const CubicBezierTimingFunction*>(tf.get());
561 list->append(CSSCubicBezierTimingFunctionValue::create(ctf->x1(), ctf->y1(), ctf->x2(), ctf->y2()));
562 } else if (tf->isStepsTimingFunction()) {
563 const StepsTimingFunction* stf = static_cast<const StepsTimingFunction*>(tf.get());
564 list->append(CSSStepsTimingFunctionValue::create(stf->numberOfSteps(), stf->stepAtStart()));
565 } else {
566 list->append(CSSLinearTimingFunctionValue::create());
567 }
568 }
569 return list.release();
570 }
571
createLineBoxContainValue(CSSPrimitiveValueCache * primitiveValueCache,unsigned lineBoxContain)572 static PassRefPtr<CSSValue> createLineBoxContainValue(CSSPrimitiveValueCache* primitiveValueCache, unsigned lineBoxContain)
573 {
574 if (!lineBoxContain)
575 return primitiveValueCache->createIdentifierValue(CSSValueNone);
576 return CSSLineBoxContainValue::create(lineBoxContain);
577 }
578
CSSComputedStyleDeclaration(PassRefPtr<Node> n,bool allowVisitedStyle,const String & pseudoElementName)579 CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n, bool allowVisitedStyle, const String& pseudoElementName)
580 : m_node(n)
581 , m_allowVisitedStyle(allowVisitedStyle)
582 {
583 unsigned nameWithoutColonsStart = pseudoElementName[0] == ':' ? (pseudoElementName[1] == ':' ? 2 : 1) : 0;
584 m_pseudoElementSpecifier = CSSSelector::pseudoId(CSSSelector::parsePseudoType(
585 AtomicString(pseudoElementName.substring(nameWithoutColonsStart))));
586 }
587
~CSSComputedStyleDeclaration()588 CSSComputedStyleDeclaration::~CSSComputedStyleDeclaration()
589 {
590 }
591
cssText() const592 String CSSComputedStyleDeclaration::cssText() const
593 {
594 String result("");
595
596 for (unsigned i = 0; i < numComputedProperties; i++) {
597 if (i)
598 result += " ";
599 result += getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));
600 result += ": ";
601 result += getPropertyValue(computedProperties[i]);
602 result += ";";
603 }
604
605 return result;
606 }
607
setCssText(const String &,ExceptionCode & ec)608 void CSSComputedStyleDeclaration::setCssText(const String&, ExceptionCode& ec)
609 {
610 ec = NO_MODIFICATION_ALLOWED_ERR;
611 }
612
cssIdentifierForFontSizeKeyword(int keywordSize)613 static int cssIdentifierForFontSizeKeyword(int keywordSize)
614 {
615 ASSERT_ARG(keywordSize, keywordSize);
616 ASSERT_ARG(keywordSize, keywordSize <= 8);
617 return CSSValueXxSmall + keywordSize - 1;
618 }
619
getFontSizeCSSValuePreferringKeyword() const620 PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getFontSizeCSSValuePreferringKeyword() const
621 {
622 if (!m_node)
623 return 0;
624
625 m_node->document()->updateLayoutIgnorePendingStylesheets();
626
627 RefPtr<RenderStyle> style = m_node->computedStyle(m_pseudoElementSpecifier);
628 if (!style)
629 return 0;
630
631 CSSPrimitiveValueCache* primitiveValueCache = m_node->document()->cssPrimitiveValueCache().get();
632
633 if (int keywordSize = style->fontDescription().keywordSize())
634 return primitiveValueCache->createIdentifierValue(cssIdentifierForFontSizeKeyword(keywordSize));
635
636
637 return zoomAdjustedPixelValue(style->fontDescription().computedPixelSize(), style.get(), primitiveValueCache);
638 }
639
useFixedFontDefaultSize() const640 bool CSSComputedStyleDeclaration::useFixedFontDefaultSize() const
641 {
642 if (!m_node)
643 return false;
644
645 RefPtr<RenderStyle> style = m_node->computedStyle(m_pseudoElementSpecifier);
646 if (!style)
647 return false;
648
649 return style->fontDescription().useFixedDefaultSize();
650 }
651
valueForShadow(const ShadowData * shadow,int id,RenderStyle * style) const652 PassRefPtr<CSSValue> CSSComputedStyleDeclaration::valueForShadow(const ShadowData* shadow, int id, RenderStyle* style) const
653 {
654 CSSPrimitiveValueCache* primitiveValueCache = m_node->document()->cssPrimitiveValueCache().get();
655 if (!shadow)
656 return primitiveValueCache->createIdentifierValue(CSSValueNone);
657
658 CSSPropertyID propertyID = static_cast<CSSPropertyID>(id);
659
660 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
661 for (const ShadowData* s = shadow; s; s = s->next()) {
662 RefPtr<CSSPrimitiveValue> x = zoomAdjustedPixelValue(s->x(), style, primitiveValueCache);
663 RefPtr<CSSPrimitiveValue> y = zoomAdjustedPixelValue(s->y(), style, primitiveValueCache);
664 RefPtr<CSSPrimitiveValue> blur = zoomAdjustedPixelValue(s->blur(), style, primitiveValueCache);
665 RefPtr<CSSPrimitiveValue> spread = propertyID == CSSPropertyTextShadow ? PassRefPtr<CSSPrimitiveValue>() : zoomAdjustedPixelValue(s->spread(), style, primitiveValueCache);
666 RefPtr<CSSPrimitiveValue> style = propertyID == CSSPropertyTextShadow || s->style() == Normal ? PassRefPtr<CSSPrimitiveValue>() : primitiveValueCache->createIdentifierValue(CSSValueInset);
667 RefPtr<CSSPrimitiveValue> color = primitiveValueCache->createColorValue(s->color().rgb());
668 list->prepend(ShadowValue::create(x.release(), y.release(), blur.release(), spread.release(), style.release(), color.release()));
669 }
670 return list.release();
671 }
672
getPropertyCSSValue(int propertyID) const673 PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID) const
674 {
675 return getPropertyCSSValue(propertyID, UpdateLayout);
676 }
677
identifierForFamily(const AtomicString & family)678 static int identifierForFamily(const AtomicString& family)
679 {
680 DEFINE_STATIC_LOCAL(AtomicString, cursiveFamily, ("-webkit-cursive"));
681 DEFINE_STATIC_LOCAL(AtomicString, fantasyFamily, ("-webkit-fantasy"));
682 DEFINE_STATIC_LOCAL(AtomicString, monospaceFamily, ("-webkit-monospace"));
683 DEFINE_STATIC_LOCAL(AtomicString, sansSerifFamily, ("-webkit-sans-serif"));
684 DEFINE_STATIC_LOCAL(AtomicString, serifFamily, ("-webkit-serif"));
685 if (family == cursiveFamily)
686 return CSSValueCursive;
687 if (family == fantasyFamily)
688 return CSSValueFantasy;
689 if (family == monospaceFamily)
690 return CSSValueMonospace;
691 if (family == sansSerifFamily)
692 return CSSValueSansSerif;
693 if (family == serifFamily)
694 return CSSValueSerif;
695 return 0;
696 }
697
valueForFamily(const AtomicString & family,CSSPrimitiveValueCache * primitiveValueCache)698 static PassRefPtr<CSSPrimitiveValue> valueForFamily(const AtomicString& family, CSSPrimitiveValueCache* primitiveValueCache)
699 {
700 if (int familyIdentifier = identifierForFamily(family))
701 return primitiveValueCache->createIdentifierValue(familyIdentifier);
702 return primitiveValueCache->createValue(family.string(), CSSPrimitiveValue::CSS_STRING);
703 }
704
renderTextDecorationFlagsToCSSValue(int textDecoration,CSSPrimitiveValueCache * primitiveValueCache)705 static PassRefPtr<CSSValue> renderTextDecorationFlagsToCSSValue(int textDecoration, CSSPrimitiveValueCache* primitiveValueCache)
706 {
707 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
708 if (textDecoration & UNDERLINE)
709 list->append(primitiveValueCache->createIdentifierValue(CSSValueUnderline));
710 if (textDecoration & OVERLINE)
711 list->append(primitiveValueCache->createIdentifierValue(CSSValueOverline));
712 if (textDecoration & LINE_THROUGH)
713 list->append(primitiveValueCache->createIdentifierValue(CSSValueLineThrough));
714 if (textDecoration & BLINK)
715 list->append(primitiveValueCache->createIdentifierValue(CSSValueBlink));
716
717 if (!list->length())
718 return primitiveValueCache->createIdentifierValue(CSSValueNone);
719 return list;
720 }
721
fillRepeatToCSSValue(EFillRepeat xRepeat,EFillRepeat yRepeat,CSSPrimitiveValueCache * primitiveValueCache)722 static PassRefPtr<CSSValue> fillRepeatToCSSValue(EFillRepeat xRepeat, EFillRepeat yRepeat, CSSPrimitiveValueCache* primitiveValueCache)
723 {
724 // For backwards compatibility, if both values are equal, just return one of them. And
725 // if the two values are equivalent to repeat-x or repeat-y, just return the shorthand.
726 if (xRepeat == yRepeat)
727 return primitiveValueCache->createValue(xRepeat);
728 if (xRepeat == RepeatFill && yRepeat == NoRepeatFill)
729 return primitiveValueCache->createIdentifierValue(CSSValueRepeatX);
730 if (xRepeat == NoRepeatFill && yRepeat == RepeatFill)
731 return primitiveValueCache->createIdentifierValue(CSSValueRepeatY);
732
733 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
734 list->append(primitiveValueCache->createValue(xRepeat));
735 list->append(primitiveValueCache->createValue(yRepeat));
736 return list.release();
737 }
738
fillSizeToCSSValue(const FillSize & fillSize,CSSPrimitiveValueCache * primitiveValueCache)739 static PassRefPtr<CSSValue> fillSizeToCSSValue(const FillSize& fillSize, CSSPrimitiveValueCache* primitiveValueCache)
740 {
741 if (fillSize.type == Contain)
742 return primitiveValueCache->createIdentifierValue(CSSValueContain);
743
744 if (fillSize.type == Cover)
745 return primitiveValueCache->createIdentifierValue(CSSValueCover);
746
747 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
748 list->append(primitiveValueCache->createValue(fillSize.size.width()));
749 list->append(primitiveValueCache->createValue(fillSize.size.height()));
750 return list.release();
751 }
752
contentToCSSValue(const RenderStyle * style,CSSPrimitiveValueCache * primitiveValueCache)753 static PassRefPtr<CSSValue> contentToCSSValue(const RenderStyle* style, CSSPrimitiveValueCache* primitiveValueCache)
754 {
755 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
756 for (const ContentData* contentData = style->contentData(); contentData; contentData = contentData->next()) {
757 if (contentData->isCounter()) {
758 const CounterContent* counter = contentData->counter();
759 ASSERT(counter);
760 list->append(primitiveValueCache->createValue(counter->identifier(), CSSPrimitiveValue::CSS_COUNTER_NAME));
761 } else if (contentData->isImage()) {
762 const StyleImage* image = contentData->image();
763 ASSERT(image);
764 list->append(image->cssValue());
765 } else if (contentData->isText())
766 list->append(primitiveValueCache->createValue(contentData->text(), CSSPrimitiveValue::CSS_STRING));
767 }
768 return list.release();
769 }
770
counterToCSSValue(const RenderStyle * style,int propertyID,CSSPrimitiveValueCache * primitiveValueCache)771 static PassRefPtr<CSSValue> counterToCSSValue(const RenderStyle* style, int propertyID, CSSPrimitiveValueCache* primitiveValueCache)
772 {
773 const CounterDirectiveMap* map = style->counterDirectives();
774 if (!map)
775 return 0;
776
777 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
778 for (CounterDirectiveMap::const_iterator it = map->begin(); it != map->end(); ++it) {
779 list->append(primitiveValueCache->createValue(it->first.get(), CSSPrimitiveValue::CSS_STRING));
780 short number = propertyID == CSSPropertyCounterIncrement ? it->second.m_incrementValue : it->second.m_resetValue;
781 list->append(primitiveValueCache->createValue((double)number, CSSPrimitiveValue::CSS_NUMBER));
782 }
783 return list.release();
784 }
785
logUnimplementedPropertyID(int propertyID)786 static void logUnimplementedPropertyID(int propertyID)
787 {
788 DEFINE_STATIC_LOCAL(HashSet<int>, propertyIDSet, ());
789 if (!propertyIDSet.add(propertyID).second)
790 return;
791
792 LOG_ERROR("WebKit does not yet implement getComputedStyle for '%s'.", getPropertyName(static_cast<CSSPropertyID>(propertyID)));
793 }
794
getPropertyCSSValue(int propertyID,EUpdateLayout updateLayout) const795 PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int propertyID, EUpdateLayout updateLayout) const
796 {
797 Node* node = m_node.get();
798 if (!node)
799 return 0;
800
801 // Make sure our layout is up to date before we allow a query on these attributes.
802 if (updateLayout)
803 node->document()->updateLayoutIgnorePendingStylesheets();
804
805 RenderObject* renderer = node->renderer();
806
807 RefPtr<RenderStyle> style;
808 if (renderer && hasCompositedLayer(renderer) && AnimationController::supportsAcceleratedAnimationOfProperty(static_cast<CSSPropertyID>(propertyID))) {
809 style = renderer->animation()->getAnimatedStyleForRenderer(renderer);
810 if (m_pseudoElementSpecifier) {
811 // FIXME: This cached pseudo style will only exist if the animation has been run at least once.
812 style = style->getCachedPseudoStyle(m_pseudoElementSpecifier);
813 }
814 } else
815 style = node->computedStyle(m_pseudoElementSpecifier);
816
817 if (!style)
818 return 0;
819
820 CSSPrimitiveValueCache* primitiveValueCache = node->document()->cssPrimitiveValueCache().get();
821
822 propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style->direction(), style->writingMode());
823
824 switch (static_cast<CSSPropertyID>(propertyID)) {
825 case CSSPropertyInvalid:
826 break;
827
828 case CSSPropertyBackgroundColor:
829 return primitiveValueCache->createColorValue(m_allowVisitedStyle? style->visitedDependentColor(CSSPropertyBackgroundColor).rgb() : style->backgroundColor().rgb());
830 case CSSPropertyBackgroundImage:
831 case CSSPropertyWebkitMaskImage: {
832 const FillLayer* layers = propertyID == CSSPropertyWebkitMaskImage ? style->maskLayers() : style->backgroundLayers();
833 if (!layers)
834 return primitiveValueCache->createIdentifierValue(CSSValueNone);
835
836 if (!layers->next()) {
837 if (layers->image())
838 return layers->image()->cssValue();
839
840 return primitiveValueCache->createIdentifierValue(CSSValueNone);
841 }
842
843 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
844 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next()) {
845 if (currLayer->image())
846 list->append(currLayer->image()->cssValue());
847 else
848 list->append(primitiveValueCache->createIdentifierValue(CSSValueNone));
849 }
850 return list.release();
851 }
852 case CSSPropertyBackgroundSize:
853 case CSSPropertyWebkitBackgroundSize:
854 case CSSPropertyWebkitMaskSize: {
855 const FillLayer* layers = propertyID == CSSPropertyWebkitMaskSize ? style->maskLayers() : style->backgroundLayers();
856 if (!layers->next())
857 return fillSizeToCSSValue(layers->size(), primitiveValueCache);
858
859 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
860 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
861 list->append(fillSizeToCSSValue(currLayer->size(), primitiveValueCache));
862
863 return list.release();
864 }
865 case CSSPropertyBackgroundRepeat:
866 case CSSPropertyWebkitMaskRepeat: {
867 const FillLayer* layers = propertyID == CSSPropertyWebkitMaskRepeat ? style->maskLayers() : style->backgroundLayers();
868 if (!layers->next())
869 return fillRepeatToCSSValue(layers->repeatX(), layers->repeatY(), primitiveValueCache);
870
871 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
872 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
873 list->append(fillRepeatToCSSValue(currLayer->repeatX(), currLayer->repeatY(), primitiveValueCache));
874
875 return list.release();
876 }
877 case CSSPropertyWebkitBackgroundComposite:
878 case CSSPropertyWebkitMaskComposite: {
879 const FillLayer* layers = propertyID == CSSPropertyWebkitMaskComposite ? style->maskLayers() : style->backgroundLayers();
880 if (!layers->next())
881 return primitiveValueCache->createValue(layers->composite());
882
883 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
884 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
885 list->append(primitiveValueCache->createValue(currLayer->composite()));
886
887 return list.release();
888 }
889 case CSSPropertyBackgroundAttachment:
890 case CSSPropertyWebkitMaskAttachment: {
891 const FillLayer* layers = propertyID == CSSPropertyWebkitMaskAttachment ? style->maskLayers() : style->backgroundLayers();
892 if (!layers->next())
893 return primitiveValueCache->createValue(layers->attachment());
894
895 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
896 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
897 list->append(primitiveValueCache->createValue(currLayer->attachment()));
898
899 return list.release();
900 }
901 case CSSPropertyBackgroundClip:
902 case CSSPropertyBackgroundOrigin:
903 case CSSPropertyWebkitBackgroundClip:
904 case CSSPropertyWebkitBackgroundOrigin:
905 case CSSPropertyWebkitMaskClip:
906 case CSSPropertyWebkitMaskOrigin: {
907 const FillLayer* layers = (propertyID == CSSPropertyWebkitMaskClip || propertyID == CSSPropertyWebkitMaskOrigin) ? style->maskLayers() : style->backgroundLayers();
908 bool isClip = propertyID == CSSPropertyBackgroundClip || propertyID == CSSPropertyWebkitBackgroundClip || propertyID == CSSPropertyWebkitMaskClip;
909 if (!layers->next()) {
910 EFillBox box = isClip ? layers->clip() : layers->origin();
911 return primitiveValueCache->createValue(box);
912 }
913
914 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
915 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next()) {
916 EFillBox box = isClip ? currLayer->clip() : currLayer->origin();
917 list->append(primitiveValueCache->createValue(box));
918 }
919
920 return list.release();
921 }
922 case CSSPropertyBackgroundPosition:
923 case CSSPropertyWebkitMaskPosition: {
924 const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPosition ? style->maskLayers() : style->backgroundLayers();
925 if (!layers->next()) {
926 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
927 list->append(primitiveValueCache->createValue(layers->xPosition()));
928 list->append(primitiveValueCache->createValue(layers->yPosition()));
929 return list.release();
930 }
931
932 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
933 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next()) {
934 RefPtr<CSSValueList> positionList = CSSValueList::createSpaceSeparated();
935 positionList->append(primitiveValueCache->createValue(currLayer->xPosition()));
936 positionList->append(primitiveValueCache->createValue(currLayer->yPosition()));
937 list->append(positionList);
938 }
939
940 return list.release();
941 }
942 case CSSPropertyBackgroundPositionX:
943 case CSSPropertyWebkitMaskPositionX: {
944 const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPositionX ? style->maskLayers() : style->backgroundLayers();
945 if (!layers->next())
946 return primitiveValueCache->createValue(layers->xPosition());
947
948 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
949 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
950 list->append(primitiveValueCache->createValue(currLayer->xPosition()));
951
952 return list.release();
953 }
954 case CSSPropertyBackgroundPositionY:
955 case CSSPropertyWebkitMaskPositionY: {
956 const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPositionY ? style->maskLayers() : style->backgroundLayers();
957 if (!layers->next())
958 return primitiveValueCache->createValue(layers->yPosition());
959
960 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
961 for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
962 list->append(primitiveValueCache->createValue(currLayer->yPosition()));
963
964 return list.release();
965 }
966 case CSSPropertyBorderCollapse:
967 if (style->borderCollapse())
968 return primitiveValueCache->createIdentifierValue(CSSValueCollapse);
969 return primitiveValueCache->createIdentifierValue(CSSValueSeparate);
970 case CSSPropertyBorderSpacing: {
971 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
972 list->append(zoomAdjustedPixelValue(style->horizontalBorderSpacing(), style.get(), primitiveValueCache));
973 list->append(zoomAdjustedPixelValue(style->verticalBorderSpacing(), style.get(), primitiveValueCache));
974 return list.release();
975 }
976 case CSSPropertyWebkitBorderHorizontalSpacing:
977 return zoomAdjustedPixelValue(style->horizontalBorderSpacing(), style.get(), primitiveValueCache);
978 case CSSPropertyWebkitBorderVerticalSpacing:
979 return zoomAdjustedPixelValue(style->verticalBorderSpacing(), style.get(), primitiveValueCache);
980 case CSSPropertyBorderTopColor:
981 return m_allowVisitedStyle ? primitiveValueCache->createColorValue(style->visitedDependentColor(CSSPropertyBorderTopColor).rgb()) : currentColorOrValidColor(style.get(), style->borderTopColor());
982 case CSSPropertyBorderRightColor:
983 return m_allowVisitedStyle ? primitiveValueCache->createColorValue(style->visitedDependentColor(CSSPropertyBorderRightColor).rgb()) : currentColorOrValidColor(style.get(), style->borderRightColor());
984 case CSSPropertyBorderBottomColor:
985 return m_allowVisitedStyle ? primitiveValueCache->createColorValue(style->visitedDependentColor(CSSPropertyBorderBottomColor).rgb()) : currentColorOrValidColor(style.get(), style->borderBottomColor());
986 case CSSPropertyBorderLeftColor:
987 return m_allowVisitedStyle ? primitiveValueCache->createColorValue(style->visitedDependentColor(CSSPropertyBorderLeftColor).rgb()) : currentColorOrValidColor(style.get(), style->borderLeftColor());
988 case CSSPropertyBorderTopStyle:
989 return primitiveValueCache->createValue(style->borderTopStyle());
990 case CSSPropertyBorderRightStyle:
991 return primitiveValueCache->createValue(style->borderRightStyle());
992 case CSSPropertyBorderBottomStyle:
993 return primitiveValueCache->createValue(style->borderBottomStyle());
994 case CSSPropertyBorderLeftStyle:
995 return primitiveValueCache->createValue(style->borderLeftStyle());
996 case CSSPropertyBorderTopWidth:
997 return zoomAdjustedPixelValue(style->borderTopWidth(), style.get(), primitiveValueCache);
998 case CSSPropertyBorderRightWidth:
999 return zoomAdjustedPixelValue(style->borderRightWidth(), style.get(), primitiveValueCache);
1000 case CSSPropertyBorderBottomWidth:
1001 return zoomAdjustedPixelValue(style->borderBottomWidth(), style.get(), primitiveValueCache);
1002 case CSSPropertyBorderLeftWidth:
1003 return zoomAdjustedPixelValue(style->borderLeftWidth(), style.get(), primitiveValueCache);
1004 case CSSPropertyBottom:
1005 return getPositionOffsetValue(style.get(), CSSPropertyBottom, primitiveValueCache);
1006 case CSSPropertyWebkitBoxAlign:
1007 return primitiveValueCache->createValue(style->boxAlign());
1008 case CSSPropertyWebkitBoxDirection:
1009 return primitiveValueCache->createValue(style->boxDirection());
1010 case CSSPropertyWebkitBoxFlex:
1011 return primitiveValueCache->createValue(style->boxFlex(), CSSPrimitiveValue::CSS_NUMBER);
1012 case CSSPropertyWebkitBoxFlexGroup:
1013 return primitiveValueCache->createValue(style->boxFlexGroup(), CSSPrimitiveValue::CSS_NUMBER);
1014 case CSSPropertyWebkitBoxLines:
1015 return primitiveValueCache->createValue(style->boxLines());
1016 case CSSPropertyWebkitBoxOrdinalGroup:
1017 return primitiveValueCache->createValue(style->boxOrdinalGroup(), CSSPrimitiveValue::CSS_NUMBER);
1018 case CSSPropertyWebkitBoxOrient:
1019 return primitiveValueCache->createValue(style->boxOrient());
1020 case CSSPropertyWebkitBoxPack: {
1021 EBoxAlignment boxPack = style->boxPack();
1022 ASSERT(boxPack != BSTRETCH);
1023 ASSERT(boxPack != BBASELINE);
1024 if (boxPack == BJUSTIFY || boxPack== BBASELINE)
1025 return 0;
1026 return primitiveValueCache->createValue(boxPack);
1027 }
1028 case CSSPropertyWebkitBoxReflect:
1029 return valueForReflection(style->boxReflect(), style.get(), primitiveValueCache);
1030 case CSSPropertyBoxShadow:
1031 case CSSPropertyWebkitBoxShadow:
1032 return valueForShadow(style->boxShadow(), propertyID, style.get());
1033 case CSSPropertyCaptionSide:
1034 return primitiveValueCache->createValue(style->captionSide());
1035 case CSSPropertyClear:
1036 return primitiveValueCache->createValue(style->clear());
1037 case CSSPropertyColor:
1038 return primitiveValueCache->createColorValue(m_allowVisitedStyle ? style->visitedDependentColor(CSSPropertyColor).rgb() : style->color().rgb());
1039 case CSSPropertyWebkitColumnCount:
1040 if (style->hasAutoColumnCount())
1041 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1042 return primitiveValueCache->createValue(style->columnCount(), CSSPrimitiveValue::CSS_NUMBER);
1043 case CSSPropertyWebkitColumnGap:
1044 if (style->hasNormalColumnGap())
1045 return primitiveValueCache->createIdentifierValue(CSSValueNormal);
1046 return zoomAdjustedPixelValue(style->columnGap(), style.get(), primitiveValueCache);
1047 case CSSPropertyWebkitColumnRuleColor:
1048 return m_allowVisitedStyle ? primitiveValueCache->createColorValue(style->visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style.get(), style->columnRuleColor());
1049 case CSSPropertyWebkitColumnRuleStyle:
1050 return primitiveValueCache->createValue(style->columnRuleStyle());
1051 case CSSPropertyWebkitColumnRuleWidth:
1052 return zoomAdjustedPixelValue(style->columnRuleWidth(), style.get(), primitiveValueCache);
1053 case CSSPropertyWebkitColumnSpan:
1054 if (style->columnSpan())
1055 return primitiveValueCache->createIdentifierValue(CSSValueAll);
1056 return primitiveValueCache->createValue(1, CSSPrimitiveValue::CSS_NUMBER);
1057 case CSSPropertyWebkitColumnBreakAfter:
1058 return primitiveValueCache->createValue(style->columnBreakAfter());
1059 case CSSPropertyWebkitColumnBreakBefore:
1060 return primitiveValueCache->createValue(style->columnBreakBefore());
1061 case CSSPropertyWebkitColumnBreakInside:
1062 return primitiveValueCache->createValue(style->columnBreakInside());
1063 case CSSPropertyWebkitColumnWidth:
1064 if (style->hasAutoColumnWidth())
1065 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1066 return zoomAdjustedPixelValue(style->columnWidth(), style.get(), primitiveValueCache);
1067 case CSSPropertyCursor: {
1068 RefPtr<CSSValueList> list;
1069 CursorList* cursors = style->cursors();
1070 if (cursors && cursors->size() > 0) {
1071 list = CSSValueList::createCommaSeparated();
1072 for (unsigned i = 0; i < cursors->size(); ++i)
1073 if (StyleImage* image = cursors->at(i).image())
1074 list->append(image->cssValue());
1075 }
1076 RefPtr<CSSValue> value = primitiveValueCache->createValue(style->cursor());
1077 if (list) {
1078 list->append(value);
1079 return list.release();
1080 }
1081 return value.release();
1082 }
1083 case CSSPropertyDirection:
1084 return primitiveValueCache->createValue(style->direction());
1085 case CSSPropertyDisplay:
1086 return primitiveValueCache->createValue(style->display());
1087 case CSSPropertyEmptyCells:
1088 return primitiveValueCache->createValue(style->emptyCells());
1089 case CSSPropertyFloat:
1090 return primitiveValueCache->createValue(style->floating());
1091 case CSSPropertyFontFamily: {
1092 const FontFamily& firstFamily = style->fontDescription().family();
1093 if (!firstFamily.next())
1094 return valueForFamily(firstFamily.family(), primitiveValueCache);
1095 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1096 for (const FontFamily* family = &firstFamily; family; family = family->next())
1097 list->append(valueForFamily(family->family(), primitiveValueCache));
1098 return list.release();
1099 }
1100 case CSSPropertyFontSize:
1101 return zoomAdjustedPixelValue(style->fontDescription().computedPixelSize(), style.get(), primitiveValueCache);
1102 case CSSPropertyFontStyle:
1103 if (style->fontDescription().italic())
1104 return primitiveValueCache->createIdentifierValue(CSSValueItalic);
1105 return primitiveValueCache->createIdentifierValue(CSSValueNormal);
1106 case CSSPropertyFontVariant:
1107 if (style->fontDescription().smallCaps())
1108 return primitiveValueCache->createIdentifierValue(CSSValueSmallCaps);
1109 return primitiveValueCache->createIdentifierValue(CSSValueNormal);
1110 case CSSPropertyFontWeight:
1111 switch (style->fontDescription().weight()) {
1112 case FontWeight100:
1113 return primitiveValueCache->createIdentifierValue(CSSValue100);
1114 case FontWeight200:
1115 return primitiveValueCache->createIdentifierValue(CSSValue200);
1116 case FontWeight300:
1117 return primitiveValueCache->createIdentifierValue(CSSValue300);
1118 case FontWeightNormal:
1119 return primitiveValueCache->createIdentifierValue(CSSValueNormal);
1120 case FontWeight500:
1121 return primitiveValueCache->createIdentifierValue(CSSValue500);
1122 case FontWeight600:
1123 return primitiveValueCache->createIdentifierValue(CSSValue600);
1124 case FontWeightBold:
1125 return primitiveValueCache->createIdentifierValue(CSSValueBold);
1126 case FontWeight800:
1127 return primitiveValueCache->createIdentifierValue(CSSValue800);
1128 case FontWeight900:
1129 return primitiveValueCache->createIdentifierValue(CSSValue900);
1130 }
1131 ASSERT_NOT_REACHED();
1132 return primitiveValueCache->createIdentifierValue(CSSValueNormal);
1133 case CSSPropertyHeight:
1134 if (renderer)
1135 return zoomAdjustedPixelValue(sizingBox(renderer).height(), style.get(), primitiveValueCache);
1136 return zoomAdjustedPixelValueForLength(style->height(), style.get(), primitiveValueCache);
1137 case CSSPropertyWebkitHighlight:
1138 if (style->highlight() == nullAtom)
1139 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1140 return primitiveValueCache->createValue(style->highlight(), CSSPrimitiveValue::CSS_STRING);
1141 case CSSPropertyWebkitHyphens:
1142 return primitiveValueCache->createValue(style->hyphens());
1143 case CSSPropertyWebkitHyphenateCharacter:
1144 if (style->hyphenationString().isNull())
1145 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1146 return primitiveValueCache->createValue(style->hyphenationString(), CSSPrimitiveValue::CSS_STRING);
1147 case CSSPropertyWebkitHyphenateLimitAfter:
1148 if (style->hyphenationLimitAfter() < 0)
1149 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1150 return CSSPrimitiveValue::create(style->hyphenationLimitAfter(), CSSPrimitiveValue::CSS_NUMBER);
1151 case CSSPropertyWebkitHyphenateLimitBefore:
1152 if (style->hyphenationLimitBefore() < 0)
1153 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
1154 return CSSPrimitiveValue::create(style->hyphenationLimitBefore(), CSSPrimitiveValue::CSS_NUMBER);
1155 case CSSPropertyWebkitBorderFit:
1156 if (style->borderFit() == BorderFitBorder)
1157 return primitiveValueCache->createIdentifierValue(CSSValueBorder);
1158 return primitiveValueCache->createIdentifierValue(CSSValueLines);
1159 case CSSPropertyLeft:
1160 return getPositionOffsetValue(style.get(), CSSPropertyLeft, primitiveValueCache);
1161 case CSSPropertyLetterSpacing:
1162 if (!style->letterSpacing())
1163 return primitiveValueCache->createIdentifierValue(CSSValueNormal);
1164 return zoomAdjustedPixelValue(style->letterSpacing(), style.get(), primitiveValueCache);
1165 case CSSPropertyWebkitLineClamp:
1166 if (style->lineClamp().isNone())
1167 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1168 return primitiveValueCache->createValue(style->lineClamp().value(), style->lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);
1169 case CSSPropertyLineHeight: {
1170 Length length = style->lineHeight();
1171 if (length.isNegative())
1172 return primitiveValueCache->createIdentifierValue(CSSValueNormal);
1173 if (length.isPercent())
1174 // This is imperfect, because it doesn't include the zoom factor and the real computation
1175 // for how high to be in pixels does include things like minimum font size and the zoom factor.
1176 // On the other hand, since font-size doesn't include the zoom factor, we really can't do
1177 // that here either.
1178 return zoomAdjustedPixelValue(static_cast<int>(length.percent() * style->fontDescription().specifiedSize()) / 100, style.get(), primitiveValueCache);
1179 return zoomAdjustedPixelValue(length.value(), style.get(), primitiveValueCache);
1180 }
1181 case CSSPropertyListStyleImage:
1182 if (style->listStyleImage())
1183 return style->listStyleImage()->cssValue();
1184 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1185 case CSSPropertyListStylePosition:
1186 return primitiveValueCache->createValue(style->listStylePosition());
1187 case CSSPropertyListStyleType:
1188 return primitiveValueCache->createValue(style->listStyleType());
1189 case CSSPropertyWebkitLocale:
1190 if (style->locale().isNull())
1191 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1192 return primitiveValueCache->createValue(style->locale(), CSSPrimitiveValue::CSS_STRING);
1193 case CSSPropertyMarginTop: {
1194 Length marginTop = style->marginTop();
1195 if (marginTop.isPercent())
1196 return primitiveValueCache->createValue(marginTop);
1197 return zoomAdjustedPixelValue(marginTop.value(), style.get(), primitiveValueCache);
1198 }
1199 case CSSPropertyMarginRight: {
1200 Length marginRight = style->marginRight();
1201 if (marginRight.isPercent())
1202 return primitiveValueCache->createValue(marginRight);
1203 return zoomAdjustedPixelValue(marginRight.value(), style.get(), primitiveValueCache);
1204 }
1205 case CSSPropertyMarginBottom: {
1206 Length marginBottom = style->marginBottom();
1207 if (marginBottom.isPercent())
1208 return primitiveValueCache->createValue(marginBottom);
1209 return zoomAdjustedPixelValue(marginBottom.value(), style.get(), primitiveValueCache);
1210 }
1211 case CSSPropertyMarginLeft: {
1212 Length marginLeft = style->marginLeft();
1213 if (marginLeft.isPercent())
1214 return primitiveValueCache->createValue(marginLeft);
1215 return zoomAdjustedPixelValue(marginLeft.value(), style.get(), primitiveValueCache);
1216 }
1217 case CSSPropertyWebkitMarqueeDirection:
1218 return primitiveValueCache->createValue(style->marqueeDirection());
1219 case CSSPropertyWebkitMarqueeIncrement:
1220 return primitiveValueCache->createValue(style->marqueeIncrement());
1221 case CSSPropertyWebkitMarqueeRepetition:
1222 if (style->marqueeLoopCount() < 0)
1223 return primitiveValueCache->createIdentifierValue(CSSValueInfinite);
1224 return primitiveValueCache->createValue(style->marqueeLoopCount(), CSSPrimitiveValue::CSS_NUMBER);
1225 case CSSPropertyWebkitMarqueeStyle:
1226 return primitiveValueCache->createValue(style->marqueeBehavior());
1227 case CSSPropertyWebkitUserModify:
1228 return primitiveValueCache->createValue(style->userModify());
1229 case CSSPropertyMaxHeight: {
1230 const Length& maxHeight = style->maxHeight();
1231 if (maxHeight.isFixed() && maxHeight.value() == undefinedLength)
1232 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1233 return primitiveValueCache->createValue(maxHeight);
1234 }
1235 case CSSPropertyMaxWidth: {
1236 const Length& maxWidth = style->maxWidth();
1237 if (maxWidth.isFixed() && maxWidth.value() == undefinedLength)
1238 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1239 return primitiveValueCache->createValue(maxWidth);
1240 }
1241 case CSSPropertyMinHeight:
1242 return primitiveValueCache->createValue(style->minHeight());
1243 case CSSPropertyMinWidth:
1244 return primitiveValueCache->createValue(style->minWidth());
1245 case CSSPropertyOpacity:
1246 return primitiveValueCache->createValue(style->opacity(), CSSPrimitiveValue::CSS_NUMBER);
1247 case CSSPropertyOrphans:
1248 if (style->hasAutoOrphans())
1249 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1250 return primitiveValueCache->createValue(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);
1251 case CSSPropertyOutlineColor:
1252 return m_allowVisitedStyle ? primitiveValueCache->createColorValue(style->visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style.get(), style->outlineColor());
1253 case CSSPropertyOutlineOffset:
1254 return zoomAdjustedPixelValue(style->outlineOffset(), style.get(), primitiveValueCache);
1255 case CSSPropertyOutlineStyle:
1256 if (style->outlineStyleIsAuto())
1257 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1258 return primitiveValueCache->createValue(style->outlineStyle());
1259 case CSSPropertyOutlineWidth:
1260 return zoomAdjustedPixelValue(style->outlineWidth(), style.get(), primitiveValueCache);
1261 case CSSPropertyOverflow:
1262 return primitiveValueCache->createValue(max(style->overflowX(), style->overflowY()));
1263 case CSSPropertyOverflowX:
1264 return primitiveValueCache->createValue(style->overflowX());
1265 case CSSPropertyOverflowY:
1266 return primitiveValueCache->createValue(style->overflowY());
1267 case CSSPropertyPaddingTop:
1268 if (renderer && renderer->isBox())
1269 return zoomAdjustedPixelValue(toRenderBox(renderer)->paddingTop(false), style.get(), primitiveValueCache);
1270 return primitiveValueCache->createValue(style->paddingTop());
1271 case CSSPropertyPaddingRight:
1272 if (renderer && renderer->isBox())
1273 return zoomAdjustedPixelValue(toRenderBox(renderer)->paddingRight(false), style.get(), primitiveValueCache);
1274 return primitiveValueCache->createValue(style->paddingRight());
1275 case CSSPropertyPaddingBottom:
1276 if (renderer && renderer->isBox())
1277 return zoomAdjustedPixelValue(toRenderBox(renderer)->paddingBottom(false), style.get(), primitiveValueCache);
1278 return primitiveValueCache->createValue(style->paddingBottom());
1279 case CSSPropertyPaddingLeft:
1280 if (renderer && renderer->isBox())
1281 return zoomAdjustedPixelValue(toRenderBox(renderer)->paddingLeft(false), style.get(), primitiveValueCache);
1282 return primitiveValueCache->createValue(style->paddingLeft());
1283 case CSSPropertyPageBreakAfter:
1284 return primitiveValueCache->createValue(style->pageBreakAfter());
1285 case CSSPropertyPageBreakBefore:
1286 return primitiveValueCache->createValue(style->pageBreakBefore());
1287 case CSSPropertyPageBreakInside: {
1288 EPageBreak pageBreak = style->pageBreakInside();
1289 ASSERT(pageBreak != PBALWAYS);
1290 if (pageBreak == PBALWAYS)
1291 return 0;
1292 return primitiveValueCache->createValue(style->pageBreakInside());
1293 }
1294 case CSSPropertyPosition:
1295 return primitiveValueCache->createValue(style->position());
1296 case CSSPropertyRight:
1297 return getPositionOffsetValue(style.get(), CSSPropertyRight, primitiveValueCache);
1298 case CSSPropertyTableLayout:
1299 return primitiveValueCache->createValue(style->tableLayout());
1300 case CSSPropertyTextAlign:
1301 return primitiveValueCache->createValue(style->textAlign());
1302 case CSSPropertyTextDecoration:
1303 return renderTextDecorationFlagsToCSSValue(style->textDecoration(), primitiveValueCache);
1304 case CSSPropertyWebkitTextDecorationsInEffect:
1305 return renderTextDecorationFlagsToCSSValue(style->textDecorationsInEffect(), primitiveValueCache);
1306 case CSSPropertyWebkitTextFillColor:
1307 return currentColorOrValidColor(style.get(), style->textFillColor());
1308 case CSSPropertyWebkitTextEmphasisColor:
1309 return currentColorOrValidColor(style.get(), style->textEmphasisColor());
1310 case CSSPropertyWebkitTextEmphasisPosition:
1311 return primitiveValueCache->createValue(style->textEmphasisPosition());
1312 case CSSPropertyWebkitTextEmphasisStyle:
1313 switch (style->textEmphasisMark()) {
1314 case TextEmphasisMarkNone:
1315 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1316 case TextEmphasisMarkCustom:
1317 return primitiveValueCache->createValue(style->textEmphasisCustomMark(), CSSPrimitiveValue::CSS_STRING);
1318 case TextEmphasisMarkAuto:
1319 ASSERT_NOT_REACHED();
1320 // Fall through
1321 case TextEmphasisMarkDot:
1322 case TextEmphasisMarkCircle:
1323 case TextEmphasisMarkDoubleCircle:
1324 case TextEmphasisMarkTriangle:
1325 case TextEmphasisMarkSesame: {
1326 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1327 list->append(primitiveValueCache->createValue(style->textEmphasisFill()));
1328 list->append(primitiveValueCache->createValue(style->textEmphasisMark()));
1329 return list.release();
1330 }
1331 }
1332 case CSSPropertyTextIndent:
1333 return primitiveValueCache->createValue(style->textIndent());
1334 case CSSPropertyTextShadow:
1335 return valueForShadow(style->textShadow(), propertyID, style.get());
1336 case CSSPropertyTextRendering:
1337 return primitiveValueCache->createValue(style->fontDescription().textRenderingMode());
1338 case CSSPropertyTextOverflow:
1339 if (style->textOverflow())
1340 return primitiveValueCache->createIdentifierValue(CSSValueEllipsis);
1341 return primitiveValueCache->createIdentifierValue(CSSValueClip);
1342 case CSSPropertyWebkitTextSecurity:
1343 return primitiveValueCache->createValue(style->textSecurity());
1344 case CSSPropertyWebkitTextSizeAdjust:
1345 if (style->textSizeAdjust())
1346 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1347 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1348 case CSSPropertyWebkitTextStrokeColor:
1349 return currentColorOrValidColor(style.get(), style->textStrokeColor());
1350 case CSSPropertyWebkitTextStrokeWidth:
1351 return zoomAdjustedPixelValue(style->textStrokeWidth(), style.get(), primitiveValueCache);
1352 case CSSPropertyTextTransform:
1353 return primitiveValueCache->createValue(style->textTransform());
1354 case CSSPropertyTop:
1355 return getPositionOffsetValue(style.get(), CSSPropertyTop, primitiveValueCache);
1356 case CSSPropertyUnicodeBidi:
1357 return primitiveValueCache->createValue(style->unicodeBidi());
1358 case CSSPropertyVerticalAlign:
1359 switch (style->verticalAlign()) {
1360 case BASELINE:
1361 return primitiveValueCache->createIdentifierValue(CSSValueBaseline);
1362 case MIDDLE:
1363 return primitiveValueCache->createIdentifierValue(CSSValueMiddle);
1364 case SUB:
1365 return primitiveValueCache->createIdentifierValue(CSSValueSub);
1366 case SUPER:
1367 return primitiveValueCache->createIdentifierValue(CSSValueSuper);
1368 case TEXT_TOP:
1369 return primitiveValueCache->createIdentifierValue(CSSValueTextTop);
1370 case TEXT_BOTTOM:
1371 return primitiveValueCache->createIdentifierValue(CSSValueTextBottom);
1372 case TOP:
1373 return primitiveValueCache->createIdentifierValue(CSSValueTop);
1374 case BOTTOM:
1375 return primitiveValueCache->createIdentifierValue(CSSValueBottom);
1376 case BASELINE_MIDDLE:
1377 return primitiveValueCache->createIdentifierValue(CSSValueWebkitBaselineMiddle);
1378 case LENGTH:
1379 return primitiveValueCache->createValue(style->verticalAlignLength());
1380 }
1381 ASSERT_NOT_REACHED();
1382 return 0;
1383 case CSSPropertyVisibility:
1384 return primitiveValueCache->createValue(style->visibility());
1385 case CSSPropertyWhiteSpace:
1386 return primitiveValueCache->createValue(style->whiteSpace());
1387 case CSSPropertyWidows:
1388 if (style->hasAutoWidows())
1389 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1390 return primitiveValueCache->createValue(style->widows(), CSSPrimitiveValue::CSS_NUMBER);
1391 case CSSPropertyWidth:
1392 if (renderer)
1393 return zoomAdjustedPixelValue(sizingBox(renderer).width(), style.get(), primitiveValueCache);
1394 return zoomAdjustedPixelValueForLength(style->width(), style.get(), primitiveValueCache);
1395 case CSSPropertyWordBreak:
1396 return primitiveValueCache->createValue(style->wordBreak());
1397 case CSSPropertyWordSpacing:
1398 return zoomAdjustedPixelValue(style->wordSpacing(), style.get(), primitiveValueCache);
1399 case CSSPropertyWordWrap:
1400 return primitiveValueCache->createValue(style->wordWrap());
1401 case CSSPropertyWebkitLineBreak:
1402 return primitiveValueCache->createValue(style->khtmlLineBreak());
1403 case CSSPropertyWebkitNbspMode:
1404 return primitiveValueCache->createValue(style->nbspMode());
1405 case CSSPropertyWebkitMatchNearestMailBlockquoteColor:
1406 return primitiveValueCache->createValue(style->matchNearestMailBlockquoteColor());
1407 case CSSPropertyResize:
1408 return primitiveValueCache->createValue(style->resize());
1409 case CSSPropertyWebkitFontSmoothing:
1410 return primitiveValueCache->createValue(style->fontDescription().fontSmoothing());
1411 case CSSPropertyZIndex:
1412 if (style->hasAutoZIndex())
1413 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1414 return primitiveValueCache->createValue(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);
1415 case CSSPropertyZoom:
1416 return primitiveValueCache->createValue(style->zoom(), CSSPrimitiveValue::CSS_NUMBER);
1417 case CSSPropertyBoxSizing:
1418 if (style->boxSizing() == CONTENT_BOX)
1419 return primitiveValueCache->createIdentifierValue(CSSValueContentBox);
1420 return primitiveValueCache->createIdentifierValue(CSSValueBorderBox);
1421 #if ENABLE(DASHBOARD_SUPPORT)
1422 case CSSPropertyWebkitDashboardRegion:
1423 {
1424 const Vector<StyleDashboardRegion>& regions = style->dashboardRegions();
1425 unsigned count = regions.size();
1426 if (count == 1 && regions[0].type == StyleDashboardRegion::None)
1427 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1428
1429 RefPtr<DashboardRegion> firstRegion;
1430 DashboardRegion* previousRegion = 0;
1431 for (unsigned i = 0; i < count; i++) {
1432 RefPtr<DashboardRegion> region = DashboardRegion::create();
1433 StyleDashboardRegion styleRegion = regions[i];
1434
1435 region->m_label = styleRegion.label;
1436 LengthBox offset = styleRegion.offset;
1437 region->setTop(zoomAdjustedPixelValue(offset.top().value(), style.get(), primitiveValueCache));
1438 region->setRight(zoomAdjustedPixelValue(offset.right().value(), style.get(), primitiveValueCache));
1439 region->setBottom(zoomAdjustedPixelValue(offset.bottom().value(), style.get(), primitiveValueCache));
1440 region->setLeft(zoomAdjustedPixelValue(offset.left().value(), style.get(), primitiveValueCache));
1441 region->m_isRectangle = (styleRegion.type == StyleDashboardRegion::Rectangle);
1442 region->m_isCircle = (styleRegion.type == StyleDashboardRegion::Circle);
1443
1444 if (previousRegion)
1445 previousRegion->m_next = region;
1446 else
1447 firstRegion = region;
1448 previousRegion = region.get();
1449 }
1450 return primitiveValueCache->createValue(firstRegion.release());
1451 }
1452 #endif
1453 case CSSPropertyWebkitAnimationDelay:
1454 return getDelayValue(style->animations(), primitiveValueCache);
1455 case CSSPropertyWebkitAnimationDirection: {
1456 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1457 const AnimationList* t = style->animations();
1458 if (t) {
1459 for (size_t i = 0; i < t->size(); ++i) {
1460 if (t->animation(i)->direction())
1461 list->append(primitiveValueCache->createIdentifierValue(CSSValueAlternate));
1462 else
1463 list->append(primitiveValueCache->createIdentifierValue(CSSValueNormal));
1464 }
1465 } else
1466 list->append(primitiveValueCache->createIdentifierValue(CSSValueNormal));
1467 return list.release();
1468 }
1469 case CSSPropertyWebkitAnimationDuration:
1470 return getDurationValue(style->animations(), primitiveValueCache);
1471 case CSSPropertyWebkitAnimationFillMode: {
1472 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1473 const AnimationList* t = style->animations();
1474 if (t) {
1475 for (size_t i = 0; i < t->size(); ++i) {
1476 switch (t->animation(i)->fillMode()) {
1477 case AnimationFillModeNone:
1478 list->append(primitiveValueCache->createIdentifierValue(CSSValueNone));
1479 break;
1480 case AnimationFillModeForwards:
1481 list->append(primitiveValueCache->createIdentifierValue(CSSValueForwards));
1482 break;
1483 case AnimationFillModeBackwards:
1484 list->append(primitiveValueCache->createIdentifierValue(CSSValueBackwards));
1485 break;
1486 case AnimationFillModeBoth:
1487 list->append(primitiveValueCache->createIdentifierValue(CSSValueBoth));
1488 break;
1489 }
1490 }
1491 } else
1492 list->append(primitiveValueCache->createIdentifierValue(CSSValueNone));
1493 return list.release();
1494 }
1495 case CSSPropertyWebkitAnimationIterationCount: {
1496 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1497 const AnimationList* t = style->animations();
1498 if (t) {
1499 for (size_t i = 0; i < t->size(); ++i) {
1500 int iterationCount = t->animation(i)->iterationCount();
1501 if (iterationCount == Animation::IterationCountInfinite)
1502 list->append(primitiveValueCache->createIdentifierValue(CSSValueInfinite));
1503 else
1504 list->append(primitiveValueCache->createValue(iterationCount, CSSPrimitiveValue::CSS_NUMBER));
1505 }
1506 } else
1507 list->append(primitiveValueCache->createValue(Animation::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
1508 return list.release();
1509 }
1510 case CSSPropertyWebkitAnimationName: {
1511 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1512 const AnimationList* t = style->animations();
1513 if (t) {
1514 for (size_t i = 0; i < t->size(); ++i)
1515 list->append(primitiveValueCache->createValue(t->animation(i)->name(), CSSPrimitiveValue::CSS_STRING));
1516 } else
1517 list->append(primitiveValueCache->createIdentifierValue(CSSValueNone));
1518 return list.release();
1519 }
1520 case CSSPropertyWebkitAnimationPlayState: {
1521 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1522 const AnimationList* t = style->animations();
1523 if (t) {
1524 for (size_t i = 0; i < t->size(); ++i) {
1525 int prop = t->animation(i)->playState();
1526 if (prop == AnimPlayStatePlaying)
1527 list->append(primitiveValueCache->createIdentifierValue(CSSValueRunning));
1528 else
1529 list->append(primitiveValueCache->createIdentifierValue(CSSValuePaused));
1530 }
1531 } else
1532 list->append(primitiveValueCache->createIdentifierValue(CSSValueRunning));
1533 return list.release();
1534 }
1535 case CSSPropertyWebkitAnimationTimingFunction:
1536 return getTimingFunctionValue(style->animations());
1537 case CSSPropertyWebkitAppearance:
1538 return primitiveValueCache->createValue(style->appearance());
1539 case CSSPropertyWebkitBackfaceVisibility:
1540 return primitiveValueCache->createIdentifierValue((style->backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
1541 case CSSPropertyWebkitBorderImage:
1542 return valueForNinePieceImage(style->borderImage(), primitiveValueCache);
1543 case CSSPropertyWebkitMaskBoxImage:
1544 return valueForNinePieceImage(style->maskBoxImage(), primitiveValueCache);
1545 case CSSPropertyWebkitFontSizeDelta:
1546 // Not a real style property -- used by the editing engine -- so has no computed value.
1547 break;
1548 case CSSPropertyWebkitMarginBottomCollapse:
1549 case CSSPropertyWebkitMarginAfterCollapse:
1550 return primitiveValueCache->createValue(style->marginAfterCollapse());
1551 case CSSPropertyWebkitMarginTopCollapse:
1552 case CSSPropertyWebkitMarginBeforeCollapse:
1553 return primitiveValueCache->createValue(style->marginBeforeCollapse());
1554 case CSSPropertyWebkitPerspective:
1555 if (!style->hasPerspective())
1556 return primitiveValueCache->createIdentifierValue(CSSValueNone);
1557 return zoomAdjustedPixelValue(style->perspective(), style.get(), primitiveValueCache);
1558 case CSSPropertyWebkitPerspectiveOrigin: {
1559 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1560 if (renderer) {
1561 IntRect box = sizingBox(renderer);
1562 list->append(zoomAdjustedPixelValue(style->perspectiveOriginX().calcMinValue(box.width()), style.get(), primitiveValueCache));
1563 list->append(zoomAdjustedPixelValue(style->perspectiveOriginY().calcMinValue(box.height()), style.get(), primitiveValueCache));
1564 }
1565 else {
1566 list->append(zoomAdjustedPixelValueForLength(style->perspectiveOriginX(), style.get(), primitiveValueCache));
1567 list->append(zoomAdjustedPixelValueForLength(style->perspectiveOriginY(), style.get(), primitiveValueCache));
1568
1569 }
1570 return list.release();
1571 }
1572 case CSSPropertyWebkitRtlOrdering:
1573 if (style->visuallyOrdered())
1574 return primitiveValueCache->createIdentifierValue(CSSValueVisual);
1575 return primitiveValueCache->createIdentifierValue(CSSValueLogical);
1576 case CSSPropertyWebkitUserDrag:
1577 return primitiveValueCache->createValue(style->userDrag());
1578 case CSSPropertyWebkitUserSelect:
1579 return primitiveValueCache->createValue(style->userSelect());
1580 case CSSPropertyBorderBottomLeftRadius:
1581 return getBorderRadiusCornerValue(style->borderBottomLeftRadius(), style.get(), primitiveValueCache);
1582 case CSSPropertyBorderBottomRightRadius:
1583 return getBorderRadiusCornerValue(style->borderBottomRightRadius(), style.get(), primitiveValueCache);
1584 case CSSPropertyBorderTopLeftRadius:
1585 return getBorderRadiusCornerValue(style->borderTopLeftRadius(), style.get(), primitiveValueCache);
1586 case CSSPropertyBorderTopRightRadius:
1587 return getBorderRadiusCornerValue(style->borderTopRightRadius(), style.get(), primitiveValueCache);
1588 case CSSPropertyClip: {
1589 if (!style->hasClip())
1590 return primitiveValueCache->createIdentifierValue(CSSValueAuto);
1591 RefPtr<Rect> rect = Rect::create();
1592 rect->setTop(zoomAdjustedPixelValue(style->clip().top().value(), style.get(), primitiveValueCache));
1593 rect->setRight(zoomAdjustedPixelValue(style->clip().right().value(), style.get(), primitiveValueCache));
1594 rect->setBottom(zoomAdjustedPixelValue(style->clip().bottom().value(), style.get(), primitiveValueCache));
1595 rect->setLeft(zoomAdjustedPixelValue(style->clip().left().value(), style.get(), primitiveValueCache));
1596 return primitiveValueCache->createValue(rect.release());
1597 }
1598 case CSSPropertySpeak:
1599 return primitiveValueCache->createValue(style->speak());
1600 case CSSPropertyWebkitTransform:
1601 return computedTransform(renderer, style.get(), primitiveValueCache);
1602 case CSSPropertyWebkitTransformOrigin: {
1603 RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
1604 if (renderer) {
1605 IntRect box = sizingBox(renderer);
1606 list->append(zoomAdjustedPixelValue(style->transformOriginX().calcMinValue(box.width()), style.get(), primitiveValueCache));
1607 list->append(zoomAdjustedPixelValue(style->transformOriginY().calcMinValue(box.height()), style.get(), primitiveValueCache));
1608 if (style->transformOriginZ() != 0)
1609 list->append(zoomAdjustedPixelValue(style->transformOriginZ(), style.get(), primitiveValueCache));
1610 } else {
1611 list->append(zoomAdjustedPixelValueForLength(style->transformOriginX(), style.get(), primitiveValueCache));
1612 list->append(zoomAdjustedPixelValueForLength(style->transformOriginY(), style.get(), primitiveValueCache));
1613 if (style->transformOriginZ() != 0)
1614 list->append(zoomAdjustedPixelValue(style->transformOriginZ(), style.get(), primitiveValueCache));
1615 }
1616 return list.release();
1617 }
1618 case CSSPropertyWebkitTransformStyle:
1619 return primitiveValueCache->createIdentifierValue((style->transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
1620 case CSSPropertyWebkitTransitionDelay:
1621 return getDelayValue(style->transitions(), primitiveValueCache);
1622 case CSSPropertyWebkitTransitionDuration:
1623 return getDurationValue(style->transitions(), primitiveValueCache);
1624 case CSSPropertyWebkitTransitionProperty: {
1625 RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
1626 const AnimationList* t = style->transitions();
1627 if (t) {
1628 for (size_t i = 0; i < t->size(); ++i) {
1629 int prop = t->animation(i)->property();
1630 RefPtr<CSSValue> propertyValue;
1631 if (prop == cAnimateNone)
1632 propertyValue = primitiveValueCache->createIdentifierValue(CSSValueNone);
1633 else if (prop == cAnimateAll)
1634 propertyValue = primitiveValueCache->createIdentifierValue(CSSValueAll);
1635 else
1636 propertyValue = primitiveValueCache->createValue(getPropertyName(static_cast<CSSPropertyID>(prop)), CSSPrimitiveValue::CSS_STRING);
1637 list->append(propertyValue);
1638 }
1639 } else
1640 list->append(primitiveValueCache->createIdentifierValue(CSSValueAll));
1641 return list.release();
1642 }
1643 case CSSPropertyWebkitTransitionTimingFunction:
1644 return getTimingFunctionValue(style->transitions());
1645 case CSSPropertyPointerEvents:
1646 return primitiveValueCache->createValue(style->pointerEvents());
1647 case CSSPropertyWebkitColorCorrection:
1648 return primitiveValueCache->createValue(style->colorSpace());
1649 case CSSPropertyWebkitWritingMode:
1650 return primitiveValueCache->createValue(style->writingMode());
1651 case CSSPropertyWebkitTextCombine:
1652 return primitiveValueCache->createValue(style->textCombine());
1653 case CSSPropertyWebkitTextOrientation:
1654 return CSSPrimitiveValue::create(style->fontDescription().textOrientation());
1655 case CSSPropertyWebkitLineBoxContain:
1656 return createLineBoxContainValue(primitiveValueCache, style->lineBoxContain());
1657 case CSSPropertyContent:
1658 return contentToCSSValue(style.get(), primitiveValueCache);
1659 case CSSPropertyCounterIncrement:
1660 return counterToCSSValue(style.get(), propertyID, primitiveValueCache);
1661 case CSSPropertyCounterReset:
1662 return counterToCSSValue(style.get(), propertyID, primitiveValueCache);
1663
1664 /* Shorthand properties, currently not supported see bug 13658*/
1665 case CSSPropertyBackground:
1666 case CSSPropertyBorder:
1667 case CSSPropertyBorderBottom:
1668 case CSSPropertyBorderColor:
1669 case CSSPropertyBorderLeft:
1670 case CSSPropertyBorderRadius:
1671 case CSSPropertyBorderRight:
1672 case CSSPropertyBorderStyle:
1673 case CSSPropertyBorderTop:
1674 case CSSPropertyBorderWidth:
1675 case CSSPropertyFont:
1676 case CSSPropertyListStyle:
1677 case CSSPropertyMargin:
1678 case CSSPropertyOutline:
1679 case CSSPropertyPadding:
1680 break;
1681
1682 /* Individual properties not part of the spec */
1683 case CSSPropertyBackgroundRepeatX:
1684 case CSSPropertyBackgroundRepeatY:
1685 break;
1686
1687 /* Unimplemented CSS 3 properties (including CSS3 shorthand properties) */
1688 case CSSPropertyWebkitTextEmphasis:
1689 case CSSPropertyTextLineThrough:
1690 case CSSPropertyTextLineThroughColor:
1691 case CSSPropertyTextLineThroughMode:
1692 case CSSPropertyTextLineThroughStyle:
1693 case CSSPropertyTextLineThroughWidth:
1694 case CSSPropertyTextOverline:
1695 case CSSPropertyTextOverlineColor:
1696 case CSSPropertyTextOverlineMode:
1697 case CSSPropertyTextOverlineStyle:
1698 case CSSPropertyTextOverlineWidth:
1699 case CSSPropertyTextUnderline:
1700 case CSSPropertyTextUnderlineColor:
1701 case CSSPropertyTextUnderlineMode:
1702 case CSSPropertyTextUnderlineStyle:
1703 case CSSPropertyTextUnderlineWidth:
1704 break;
1705
1706 /* Directional properties are resolved by resolveDirectionAwareProperty() before the switch. */
1707 case CSSPropertyWebkitBorderEnd:
1708 case CSSPropertyWebkitBorderEndColor:
1709 case CSSPropertyWebkitBorderEndStyle:
1710 case CSSPropertyWebkitBorderEndWidth:
1711 case CSSPropertyWebkitBorderStart:
1712 case CSSPropertyWebkitBorderStartColor:
1713 case CSSPropertyWebkitBorderStartStyle:
1714 case CSSPropertyWebkitBorderStartWidth:
1715 case CSSPropertyWebkitBorderAfter:
1716 case CSSPropertyWebkitBorderAfterColor:
1717 case CSSPropertyWebkitBorderAfterStyle:
1718 case CSSPropertyWebkitBorderAfterWidth:
1719 case CSSPropertyWebkitBorderBefore:
1720 case CSSPropertyWebkitBorderBeforeColor:
1721 case CSSPropertyWebkitBorderBeforeStyle:
1722 case CSSPropertyWebkitBorderBeforeWidth:
1723 case CSSPropertyWebkitMarginEnd:
1724 case CSSPropertyWebkitMarginStart:
1725 case CSSPropertyWebkitMarginAfter:
1726 case CSSPropertyWebkitMarginBefore:
1727 case CSSPropertyWebkitPaddingEnd:
1728 case CSSPropertyWebkitPaddingStart:
1729 case CSSPropertyWebkitPaddingAfter:
1730 case CSSPropertyWebkitPaddingBefore:
1731 case CSSPropertyWebkitLogicalWidth:
1732 case CSSPropertyWebkitLogicalHeight:
1733 case CSSPropertyWebkitMinLogicalWidth:
1734 case CSSPropertyWebkitMinLogicalHeight:
1735 case CSSPropertyWebkitMaxLogicalWidth:
1736 case CSSPropertyWebkitMaxLogicalHeight:
1737 ASSERT_NOT_REACHED();
1738 break;
1739
1740 /* Unimplemented @font-face properties */
1741 case CSSPropertyFontStretch:
1742 case CSSPropertySrc:
1743 case CSSPropertyUnicodeRange:
1744 break;
1745
1746 /* Other unimplemented properties */
1747 case CSSPropertyPage: // for @page
1748 case CSSPropertyQuotes: // FIXME: needs implementation
1749 case CSSPropertySize: // for @page
1750 break;
1751
1752 /* Unimplemented -webkit- properties */
1753 case CSSPropertyWebkitAnimation:
1754 case CSSPropertyWebkitBorderRadius:
1755 case CSSPropertyWebkitColumns:
1756 case CSSPropertyWebkitColumnRule:
1757 case CSSPropertyWebkitMarginCollapse:
1758 case CSSPropertyWebkitMarquee:
1759 case CSSPropertyWebkitMarqueeSpeed:
1760 case CSSPropertyWebkitMask:
1761 case CSSPropertyWebkitMaskRepeatX:
1762 case CSSPropertyWebkitMaskRepeatY:
1763 case CSSPropertyWebkitPerspectiveOriginX:
1764 case CSSPropertyWebkitPerspectiveOriginY:
1765 case CSSPropertyWebkitTextStroke:
1766 case CSSPropertyWebkitTransformOriginX:
1767 case CSSPropertyWebkitTransformOriginY:
1768 case CSSPropertyWebkitTransformOriginZ:
1769 case CSSPropertyWebkitTransition:
1770 break;
1771 #if ENABLE(SVG)
1772 case CSSPropertyClipPath:
1773 case CSSPropertyClipRule:
1774 case CSSPropertyMask:
1775 case CSSPropertyEnableBackground:
1776 case CSSPropertyFilter:
1777 case CSSPropertyFloodColor:
1778 case CSSPropertyFloodOpacity:
1779 case CSSPropertyLightingColor:
1780 case CSSPropertyStopColor:
1781 case CSSPropertyStopOpacity:
1782 case CSSPropertyColorInterpolation:
1783 case CSSPropertyColorInterpolationFilters:
1784 case CSSPropertyColorProfile:
1785 case CSSPropertyColorRendering:
1786 case CSSPropertyFill:
1787 case CSSPropertyFillOpacity:
1788 case CSSPropertyFillRule:
1789 case CSSPropertyImageRendering:
1790 case CSSPropertyMarker:
1791 case CSSPropertyMarkerEnd:
1792 case CSSPropertyMarkerMid:
1793 case CSSPropertyMarkerStart:
1794 case CSSPropertyShapeRendering:
1795 case CSSPropertyStroke:
1796 case CSSPropertyStrokeDasharray:
1797 case CSSPropertyStrokeDashoffset:
1798 case CSSPropertyStrokeLinecap:
1799 case CSSPropertyStrokeLinejoin:
1800 case CSSPropertyStrokeMiterlimit:
1801 case CSSPropertyStrokeOpacity:
1802 case CSSPropertyStrokeWidth:
1803 case CSSPropertyAlignmentBaseline:
1804 case CSSPropertyBaselineShift:
1805 case CSSPropertyDominantBaseline:
1806 case CSSPropertyGlyphOrientationHorizontal:
1807 case CSSPropertyGlyphOrientationVertical:
1808 case CSSPropertyKerning:
1809 case CSSPropertyTextAnchor:
1810 case CSSPropertyVectorEffect:
1811 case CSSPropertyWritingMode:
1812 case CSSPropertyWebkitSvgShadow:
1813 return getSVGPropertyCSSValue(propertyID, DoNotUpdateLayout);
1814 #endif
1815 }
1816
1817 logUnimplementedPropertyID(propertyID);
1818 return 0;
1819 }
1820
getPropertyValue(int propertyID) const1821 String CSSComputedStyleDeclaration::getPropertyValue(int propertyID) const
1822 {
1823 RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);
1824 if (value)
1825 return value->cssText();
1826 return "";
1827 }
1828
getPropertyPriority(int) const1829 bool CSSComputedStyleDeclaration::getPropertyPriority(int /*propertyID*/) const
1830 {
1831 // All computed styles have a priority of false (not "important").
1832 return false;
1833 }
1834
removeProperty(int,ExceptionCode & ec)1835 String CSSComputedStyleDeclaration::removeProperty(int /*propertyID*/, ExceptionCode& ec)
1836 {
1837 ec = NO_MODIFICATION_ALLOWED_ERR;
1838 return String();
1839 }
1840
setProperty(int,const String &,bool,ExceptionCode & ec)1841 void CSSComputedStyleDeclaration::setProperty(int /*propertyID*/, const String& /*value*/, bool /*important*/, ExceptionCode& ec)
1842 {
1843 ec = NO_MODIFICATION_ALLOWED_ERR;
1844 }
1845
virtualLength() const1846 unsigned CSSComputedStyleDeclaration::virtualLength() const
1847 {
1848 Node* node = m_node.get();
1849 if (!node)
1850 return 0;
1851
1852 RenderStyle* style = node->computedStyle(m_pseudoElementSpecifier);
1853 if (!style)
1854 return 0;
1855
1856 return numComputedProperties;
1857 }
1858
item(unsigned i) const1859 String CSSComputedStyleDeclaration::item(unsigned i) const
1860 {
1861 if (i >= length())
1862 return "";
1863
1864 return getPropertyName(static_cast<CSSPropertyID>(computedProperties[i]));
1865 }
1866
cssPropertyMatches(const CSSProperty * property) const1867 bool CSSComputedStyleDeclaration::cssPropertyMatches(const CSSProperty* property) const
1868 {
1869 if (property->id() == CSSPropertyFontSize && property->value()->isPrimitiveValue() && m_node) {
1870 m_node->document()->updateLayoutIgnorePendingStylesheets();
1871 RenderStyle* style = m_node->computedStyle(m_pseudoElementSpecifier);
1872 if (style && style->fontDescription().keywordSize()) {
1873 int sizeValue = cssIdentifierForFontSizeKeyword(style->fontDescription().keywordSize());
1874 CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(property->value());
1875 if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_IDENT && primitiveValue->getIdent() == sizeValue)
1876 return true;
1877 }
1878 }
1879
1880 return CSSStyleDeclaration::cssPropertyMatches(property);
1881 }
1882
copy() const1883 PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::copy() const
1884 {
1885 return copyPropertiesInSet(computedProperties, numComputedProperties);
1886 }
1887
makeMutable()1888 PassRefPtr<CSSMutableStyleDeclaration> CSSComputedStyleDeclaration::makeMutable()
1889 {
1890 return copy();
1891 }
1892
1893 } // namespace WebCore
1894