1 /* 2 * (C) 1999-2003 Lars Knoll (knoll (at) kde.org) 3 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved. 4 * Copyright (C) 2011 Research In Motion Limited. All rights reserved. 5 * Copyright (C) 2013 Intel Corporation. All rights reserved. 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Library 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 * Library General Public License for more details. 16 * 17 * You should have received a copy of the GNU Library General Public License 18 * along with this library; see the file COPYING.LIB. If not, write to 19 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 20 * Boston, MA 02110-1301, USA. 21 */ 22 23 #include "config.h" 24 #include "core/css/StylePropertySerializer.h" 25 26 #include "core/CSSValueKeywords.h" 27 #include "core/StylePropertyShorthand.h" 28 #include "core/css/RuntimeCSSEnabled.h" 29 #include "wtf/BitArray.h" 30 #include "wtf/text/StringBuilder.h" 31 32 namespace WebCore { 33 34 static bool isInitialOrInherit(const String& value) 35 { 36 DEFINE_STATIC_LOCAL(String, initial, ("initial")); 37 DEFINE_STATIC_LOCAL(String, inherit, ("inherit")); 38 return value.length() == 7 && (value == initial || value == inherit); 39 } 40 41 StylePropertySerializer::StylePropertySerializer(const StylePropertySet& properties) 42 : m_propertySet(properties) 43 { 44 } 45 46 String StylePropertySerializer::getPropertyText(CSSPropertyID propertyID, const String& value, bool isImportant, bool isNotFirstDecl) const 47 { 48 StringBuilder result; 49 if (isNotFirstDecl) 50 result.append(' '); 51 result.append(getPropertyName(propertyID)); 52 result.appendLiteral(": "); 53 result.append(value); 54 if (isImportant) 55 result.appendLiteral(" !important"); 56 result.append(';'); 57 return result.toString(); 58 } 59 60 String StylePropertySerializer::asText() const 61 { 62 StringBuilder result; 63 64 BitArray<numCSSProperties> shorthandPropertyUsed; 65 BitArray<numCSSProperties> shorthandPropertyAppeared; 66 67 unsigned size = m_propertySet.propertyCount(); 68 unsigned numDecls = 0; 69 for (unsigned n = 0; n < size; ++n) { 70 StylePropertySet::PropertyReference property = m_propertySet.propertyAt(n); 71 CSSPropertyID propertyID = property.id(); 72 // Only enabled or internal properties should be part of the style. 73 ASSERT(RuntimeCSSEnabled::isCSSPropertyEnabled(propertyID) || isInternalProperty(propertyID)); 74 CSSPropertyID shorthandPropertyID = CSSPropertyInvalid; 75 CSSPropertyID borderFallbackShorthandProperty = CSSPropertyInvalid; 76 String value; 77 78 switch (propertyID) { 79 case CSSPropertyBackgroundAttachment: 80 case CSSPropertyBackgroundClip: 81 case CSSPropertyBackgroundColor: 82 case CSSPropertyBackgroundImage: 83 case CSSPropertyBackgroundOrigin: 84 case CSSPropertyBackgroundPositionX: 85 case CSSPropertyBackgroundPositionY: 86 case CSSPropertyBackgroundSize: 87 case CSSPropertyBackgroundRepeatX: 88 case CSSPropertyBackgroundRepeatY: 89 shorthandPropertyAppeared.set(CSSPropertyBackground - firstCSSProperty); 90 continue; 91 case CSSPropertyContent: 92 if (property.value()->isValueList()) 93 value = toCSSValueList(property.value())->customCSSText(AlwaysQuoteCSSString); 94 break; 95 case CSSPropertyBorderTopWidth: 96 case CSSPropertyBorderRightWidth: 97 case CSSPropertyBorderBottomWidth: 98 case CSSPropertyBorderLeftWidth: 99 if (!borderFallbackShorthandProperty) 100 borderFallbackShorthandProperty = CSSPropertyBorderWidth; 101 case CSSPropertyBorderTopStyle: 102 case CSSPropertyBorderRightStyle: 103 case CSSPropertyBorderBottomStyle: 104 case CSSPropertyBorderLeftStyle: 105 if (!borderFallbackShorthandProperty) 106 borderFallbackShorthandProperty = CSSPropertyBorderStyle; 107 case CSSPropertyBorderTopColor: 108 case CSSPropertyBorderRightColor: 109 case CSSPropertyBorderBottomColor: 110 case CSSPropertyBorderLeftColor: 111 if (!borderFallbackShorthandProperty) 112 borderFallbackShorthandProperty = CSSPropertyBorderColor; 113 114 // FIXME: Deal with cases where only some of border-(top|right|bottom|left) are specified. 115 if (!shorthandPropertyAppeared.get(CSSPropertyBorder - firstCSSProperty)) { 116 value = borderPropertyValue(ReturnNullOnUncommonValues); 117 if (value.isNull()) 118 shorthandPropertyAppeared.set(CSSPropertyBorder - firstCSSProperty); 119 else 120 shorthandPropertyID = CSSPropertyBorder; 121 } else if (shorthandPropertyUsed.get(CSSPropertyBorder - firstCSSProperty)) 122 shorthandPropertyID = CSSPropertyBorder; 123 if (!shorthandPropertyID) 124 shorthandPropertyID = borderFallbackShorthandProperty; 125 break; 126 case CSSPropertyWebkitBorderHorizontalSpacing: 127 case CSSPropertyWebkitBorderVerticalSpacing: 128 shorthandPropertyID = CSSPropertyBorderSpacing; 129 break; 130 case CSSPropertyFontFamily: 131 case CSSPropertyLineHeight: 132 case CSSPropertyFontSize: 133 case CSSPropertyFontStyle: 134 case CSSPropertyFontVariant: 135 case CSSPropertyFontWeight: 136 // Don't use CSSPropertyFont because old UAs can't recognize them but are important for editing. 137 break; 138 case CSSPropertyListStyleType: 139 case CSSPropertyListStylePosition: 140 case CSSPropertyListStyleImage: 141 shorthandPropertyID = CSSPropertyListStyle; 142 break; 143 case CSSPropertyMarginTop: 144 case CSSPropertyMarginRight: 145 case CSSPropertyMarginBottom: 146 case CSSPropertyMarginLeft: 147 shorthandPropertyID = CSSPropertyMargin; 148 break; 149 case CSSPropertyOutlineWidth: 150 case CSSPropertyOutlineStyle: 151 case CSSPropertyOutlineColor: 152 shorthandPropertyID = CSSPropertyOutline; 153 break; 154 case CSSPropertyOverflowX: 155 case CSSPropertyOverflowY: 156 shorthandPropertyID = CSSPropertyOverflow; 157 break; 158 case CSSPropertyPaddingTop: 159 case CSSPropertyPaddingRight: 160 case CSSPropertyPaddingBottom: 161 case CSSPropertyPaddingLeft: 162 shorthandPropertyID = CSSPropertyPadding; 163 break; 164 case CSSPropertyTransitionProperty: 165 case CSSPropertyTransitionDuration: 166 case CSSPropertyTransitionTimingFunction: 167 case CSSPropertyTransitionDelay: 168 shorthandPropertyID = CSSPropertyTransition; 169 break; 170 case CSSPropertyWebkitAnimationName: 171 case CSSPropertyWebkitAnimationDuration: 172 case CSSPropertyWebkitAnimationTimingFunction: 173 case CSSPropertyWebkitAnimationDelay: 174 case CSSPropertyWebkitAnimationIterationCount: 175 case CSSPropertyWebkitAnimationDirection: 176 case CSSPropertyWebkitAnimationFillMode: 177 shorthandPropertyID = CSSPropertyWebkitAnimation; 178 break; 179 case CSSPropertyFlexDirection: 180 case CSSPropertyFlexWrap: 181 shorthandPropertyID = CSSPropertyFlexFlow; 182 break; 183 case CSSPropertyFlexBasis: 184 case CSSPropertyFlexGrow: 185 case CSSPropertyFlexShrink: 186 shorthandPropertyID = CSSPropertyFlex; 187 break; 188 case CSSPropertyWebkitMaskPositionX: 189 case CSSPropertyWebkitMaskPositionY: 190 case CSSPropertyWebkitMaskRepeatX: 191 case CSSPropertyWebkitMaskRepeatY: 192 case CSSPropertyWebkitMaskImage: 193 case CSSPropertyWebkitMaskRepeat: 194 case CSSPropertyWebkitMaskPosition: 195 case CSSPropertyWebkitMaskClip: 196 case CSSPropertyWebkitMaskOrigin: 197 shorthandPropertyID = CSSPropertyWebkitMask; 198 break; 199 case CSSPropertyWebkitTransformOriginX: 200 case CSSPropertyWebkitTransformOriginY: 201 case CSSPropertyWebkitTransformOriginZ: 202 shorthandPropertyID = CSSPropertyWebkitTransformOrigin; 203 break; 204 case CSSPropertyWebkitTransitionProperty: 205 case CSSPropertyWebkitTransitionDuration: 206 case CSSPropertyWebkitTransitionTimingFunction: 207 case CSSPropertyWebkitTransitionDelay: 208 shorthandPropertyID = CSSPropertyWebkitTransition; 209 break; 210 default: 211 break; 212 } 213 214 unsigned shortPropertyIndex = shorthandPropertyID - firstCSSProperty; 215 if (shorthandPropertyID) { 216 if (shorthandPropertyUsed.get(shortPropertyIndex)) 217 continue; 218 if (!shorthandPropertyAppeared.get(shortPropertyIndex) && value.isNull()) 219 value = m_propertySet.getPropertyValue(shorthandPropertyID); 220 shorthandPropertyAppeared.set(shortPropertyIndex); 221 } 222 223 if (!value.isNull()) { 224 if (shorthandPropertyID) { 225 propertyID = shorthandPropertyID; 226 shorthandPropertyUsed.set(shortPropertyIndex); 227 } 228 } else 229 value = property.value()->cssText(); 230 231 if (value == "initial" && !CSSProperty::isInheritedProperty(propertyID)) 232 continue; 233 234 result.append(getPropertyText(propertyID, value, property.isImportant(), numDecls++)); 235 } 236 237 if (shorthandPropertyAppeared.get(CSSPropertyBackground - firstCSSProperty)) 238 appendBackgroundPropertyAsText(result, numDecls); 239 240 ASSERT(!numDecls ^ !result.isEmpty()); 241 return result.toString(); 242 } 243 244 String StylePropertySerializer::getPropertyValue(CSSPropertyID propertyID) const 245 { 246 // Shorthand and 4-values properties 247 switch (propertyID) { 248 case CSSPropertyAnimation: 249 return getLayeredShorthandValue(animationShorthand()); 250 case CSSPropertyBorderSpacing: 251 return borderSpacingValue(borderSpacingShorthand()); 252 case CSSPropertyBackgroundPosition: 253 return getLayeredShorthandValue(backgroundPositionShorthand()); 254 case CSSPropertyBackgroundRepeat: 255 return backgroundRepeatPropertyValue(); 256 case CSSPropertyBackground: 257 return getLayeredShorthandValue(backgroundShorthand()); 258 case CSSPropertyBorder: 259 return borderPropertyValue(OmitUncommonValues); 260 case CSSPropertyBorderTop: 261 return getShorthandValue(borderTopShorthand()); 262 case CSSPropertyBorderRight: 263 return getShorthandValue(borderRightShorthand()); 264 case CSSPropertyBorderBottom: 265 return getShorthandValue(borderBottomShorthand()); 266 case CSSPropertyBorderLeft: 267 return getShorthandValue(borderLeftShorthand()); 268 case CSSPropertyOutline: 269 return getShorthandValue(outlineShorthand()); 270 case CSSPropertyBorderColor: 271 return get4Values(borderColorShorthand()); 272 case CSSPropertyBorderWidth: 273 return get4Values(borderWidthShorthand()); 274 case CSSPropertyBorderStyle: 275 return get4Values(borderStyleShorthand()); 276 case CSSPropertyWebkitColumnRule: 277 return getShorthandValue(webkitColumnRuleShorthand()); 278 case CSSPropertyWebkitColumns: 279 return getShorthandValue(webkitColumnsShorthand()); 280 case CSSPropertyFlex: 281 return getShorthandValue(flexShorthand()); 282 case CSSPropertyFlexFlow: 283 return getShorthandValue(flexFlowShorthand()); 284 case CSSPropertyGridColumn: 285 return getShorthandValue(gridColumnShorthand()); 286 case CSSPropertyGridRow: 287 return getShorthandValue(gridRowShorthand()); 288 case CSSPropertyGridArea: 289 return getShorthandValue(gridAreaShorthand()); 290 case CSSPropertyFont: 291 return fontValue(); 292 case CSSPropertyMargin: 293 return get4Values(marginShorthand()); 294 case CSSPropertyWebkitMarginCollapse: 295 return getShorthandValue(webkitMarginCollapseShorthand()); 296 case CSSPropertyOverflow: 297 return getCommonValue(overflowShorthand()); 298 case CSSPropertyPadding: 299 return get4Values(paddingShorthand()); 300 case CSSPropertyTransition: 301 return getLayeredShorthandValue(transitionShorthand()); 302 case CSSPropertyListStyle: 303 return getShorthandValue(listStyleShorthand()); 304 case CSSPropertyWebkitMaskPosition: 305 return getLayeredShorthandValue(webkitMaskPositionShorthand()); 306 case CSSPropertyWebkitMaskRepeat: 307 return getLayeredShorthandValue(webkitMaskRepeatShorthand()); 308 case CSSPropertyWebkitMask: 309 return getLayeredShorthandValue(webkitMaskShorthand()); 310 case CSSPropertyWebkitTextEmphasis: 311 return getShorthandValue(webkitTextEmphasisShorthand()); 312 case CSSPropertyWebkitTextStroke: 313 return getShorthandValue(webkitTextStrokeShorthand()); 314 case CSSPropertyTransformOrigin: 315 case CSSPropertyWebkitTransformOrigin: 316 return getShorthandValue(webkitTransformOriginShorthand()); 317 case CSSPropertyWebkitTransition: 318 return getLayeredShorthandValue(webkitTransitionShorthand()); 319 case CSSPropertyWebkitAnimation: 320 return getLayeredShorthandValue(webkitAnimationShorthand()); 321 case CSSPropertyMarker: { 322 RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyMarkerStart); 323 if (value) 324 return value->cssText(); 325 return String(); 326 } 327 case CSSPropertyBorderRadius: 328 return get4Values(borderRadiusShorthand()); 329 default: 330 return String(); 331 } 332 } 333 334 String StylePropertySerializer::borderSpacingValue(const StylePropertyShorthand& shorthand) const 335 { 336 RefPtrWillBeRawPtr<CSSValue> horizontalValue = m_propertySet.getPropertyCSSValue(shorthand.properties()[0]); 337 RefPtrWillBeRawPtr<CSSValue> verticalValue = m_propertySet.getPropertyCSSValue(shorthand.properties()[1]); 338 339 // While standard border-spacing property does not allow specifying border-spacing-vertical without 340 // specifying border-spacing-horizontal <http://www.w3.org/TR/CSS21/tables.html#separated-borders>, 341 // -webkit-border-spacing-vertical can be set without -webkit-border-spacing-horizontal. 342 if (!horizontalValue || !verticalValue) 343 return String(); 344 345 String horizontalValueCSSText = horizontalValue->cssText(); 346 String verticalValueCSSText = verticalValue->cssText(); 347 if (horizontalValueCSSText == verticalValueCSSText) 348 return horizontalValueCSSText; 349 return horizontalValueCSSText + ' ' + verticalValueCSSText; 350 } 351 352 void StylePropertySerializer::appendFontLonghandValueIfExplicit(CSSPropertyID propertyID, StringBuilder& result, String& commonValue) const 353 { 354 int foundPropertyIndex = m_propertySet.findPropertyIndex(propertyID); 355 if (foundPropertyIndex == -1) 356 return; // All longhands must have at least implicit values if "font" is specified. 357 358 if (m_propertySet.propertyAt(foundPropertyIndex).isImplicit()) { 359 commonValue = String(); 360 return; 361 } 362 363 char prefix = '\0'; 364 switch (propertyID) { 365 case CSSPropertyFontStyle: 366 break; // No prefix. 367 case CSSPropertyFontFamily: 368 case CSSPropertyFontVariant: 369 case CSSPropertyFontWeight: 370 prefix = ' '; 371 break; 372 case CSSPropertyLineHeight: 373 prefix = '/'; 374 break; 375 default: 376 ASSERT_NOT_REACHED(); 377 } 378 379 if (prefix && !result.isEmpty()) 380 result.append(prefix); 381 String value = m_propertySet.propertyAt(foundPropertyIndex).value()->cssText(); 382 result.append(value); 383 if (!commonValue.isNull() && commonValue != value) 384 commonValue = String(); 385 } 386 387 String StylePropertySerializer::fontValue() const 388 { 389 int fontSizePropertyIndex = m_propertySet.findPropertyIndex(CSSPropertyFontSize); 390 int fontFamilyPropertyIndex = m_propertySet.findPropertyIndex(CSSPropertyFontFamily); 391 if (fontSizePropertyIndex == -1 || fontFamilyPropertyIndex == -1) 392 return emptyString(); 393 394 StylePropertySet::PropertyReference fontSizeProperty = m_propertySet.propertyAt(fontSizePropertyIndex); 395 StylePropertySet::PropertyReference fontFamilyProperty = m_propertySet.propertyAt(fontFamilyPropertyIndex); 396 if (fontSizeProperty.isImplicit() || fontFamilyProperty.isImplicit()) 397 return emptyString(); 398 399 String commonValue = fontSizeProperty.value()->cssText(); 400 StringBuilder result; 401 appendFontLonghandValueIfExplicit(CSSPropertyFontStyle, result, commonValue); 402 appendFontLonghandValueIfExplicit(CSSPropertyFontVariant, result, commonValue); 403 appendFontLonghandValueIfExplicit(CSSPropertyFontWeight, result, commonValue); 404 if (!result.isEmpty()) 405 result.append(' '); 406 result.append(fontSizeProperty.value()->cssText()); 407 appendFontLonghandValueIfExplicit(CSSPropertyLineHeight, result, commonValue); 408 if (!result.isEmpty()) 409 result.append(' '); 410 result.append(fontFamilyProperty.value()->cssText()); 411 if (isInitialOrInherit(commonValue)) 412 return commonValue; 413 return result.toString(); 414 } 415 416 String StylePropertySerializer::get4Values(const StylePropertyShorthand& shorthand) const 417 { 418 // Assume the properties are in the usual order top, right, bottom, left. 419 int topValueIndex = m_propertySet.findPropertyIndex(shorthand.properties()[0]); 420 int rightValueIndex = m_propertySet.findPropertyIndex(shorthand.properties()[1]); 421 int bottomValueIndex = m_propertySet.findPropertyIndex(shorthand.properties()[2]); 422 int leftValueIndex = m_propertySet.findPropertyIndex(shorthand.properties()[3]); 423 424 if (topValueIndex == -1 || rightValueIndex == -1 || bottomValueIndex == -1 || leftValueIndex == -1) 425 return String(); 426 427 StylePropertySet::PropertyReference top = m_propertySet.propertyAt(topValueIndex); 428 StylePropertySet::PropertyReference right = m_propertySet.propertyAt(rightValueIndex); 429 StylePropertySet::PropertyReference bottom = m_propertySet.propertyAt(bottomValueIndex); 430 StylePropertySet::PropertyReference left = m_propertySet.propertyAt(leftValueIndex); 431 432 // All 4 properties must be specified. 433 if (!top.value() || !right.value() || !bottom.value() || !left.value()) 434 return String(); 435 436 if (top.isInherited() && right.isInherited() && bottom.isInherited() && left.isInherited()) 437 return getValueName(CSSValueInherit); 438 439 if (top.value()->isInitialValue() || right.value()->isInitialValue() || bottom.value()->isInitialValue() || left.value()->isInitialValue()) { 440 if (top.value()->isInitialValue() && right.value()->isInitialValue() && bottom.value()->isInitialValue() && left.value()->isInitialValue() && !top.isImplicit()) { 441 // All components are "initial" and "top" is not implicit. 442 return getValueName(CSSValueInitial); 443 } 444 return String(); 445 } 446 if (top.isImportant() != right.isImportant() || right.isImportant() != bottom.isImportant() || bottom.isImportant() != left.isImportant()) 447 return String(); 448 449 bool showLeft = !right.value()->equals(*left.value()); 450 bool showBottom = !top.value()->equals(*bottom.value()) || showLeft; 451 bool showRight = !top.value()->equals(*right.value()) || showBottom; 452 453 StringBuilder result; 454 result.append(top.value()->cssText()); 455 if (showRight) { 456 result.append(' '); 457 result.append(right.value()->cssText()); 458 } 459 if (showBottom) { 460 result.append(' '); 461 result.append(bottom.value()->cssText()); 462 } 463 if (showLeft) { 464 result.append(' '); 465 result.append(left.value()->cssText()); 466 } 467 return result.toString(); 468 } 469 470 String StylePropertySerializer::getLayeredShorthandValue(const StylePropertyShorthand& shorthand) const 471 { 472 StringBuilder result; 473 474 const unsigned size = shorthand.length(); 475 // Begin by collecting the properties into an array. 476 WillBeHeapVector<RefPtrWillBeMember<CSSValue> > values(size); 477 size_t numLayers = 0; 478 479 for (unsigned i = 0; i < size; ++i) { 480 values[i] = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]); 481 if (values[i]) { 482 if (values[i]->isBaseValueList()) { 483 CSSValueList* valueList = toCSSValueList(values[i].get()); 484 numLayers = std::max(valueList->length(), numLayers); 485 } else { 486 numLayers = std::max<size_t>(1U, numLayers); 487 } 488 } 489 } 490 491 String commonValue; 492 bool commonValueInitialized = false; 493 494 // Now stitch the properties together. Implicit initial values are flagged as such and 495 // can safely be omitted. 496 for (size_t i = 0; i < numLayers; i++) { 497 StringBuilder layerResult; 498 bool useRepeatXShorthand = false; 499 bool useRepeatYShorthand = false; 500 bool useSingleWordShorthand = false; 501 bool foundPositionYCSSProperty = false; 502 for (unsigned j = 0; j < size; j++) { 503 RefPtrWillBeRawPtr<CSSValue> value = nullptr; 504 if (values[j]) { 505 if (values[j]->isBaseValueList()) 506 value = toCSSValueList(values[j].get())->item(i); 507 else { 508 value = values[j]; 509 510 // Color only belongs in the last layer. 511 if (shorthand.properties()[j] == CSSPropertyBackgroundColor) { 512 if (i != numLayers - 1) 513 value = nullptr; 514 } else if (i) { 515 // Other singletons only belong in the first layer. 516 value = nullptr; 517 } 518 } 519 } 520 521 // We need to report background-repeat as it was written in the CSS. If the property is implicit, 522 // then it was written with only one value. Here we figure out which value that was so we can 523 // report back correctly. 524 if ((shorthand.properties()[j] == CSSPropertyBackgroundRepeatX && m_propertySet.isPropertyImplicit(shorthand.properties()[j])) 525 || (shorthand.properties()[j] == CSSPropertyWebkitMaskRepeatX && m_propertySet.isPropertyImplicit(shorthand.properties()[j]))) { 526 527 // BUG 49055: make sure the value was not reset in the layer check just above. 528 if ((j < size - 1 && shorthand.properties()[j + 1] == CSSPropertyBackgroundRepeatY && value) 529 || (j < size - 1 && shorthand.properties()[j + 1] == CSSPropertyWebkitMaskRepeatY && value)) { 530 RefPtrWillBeRawPtr<CSSValue> yValue = nullptr; 531 RefPtrWillBeRawPtr<CSSValue> nextValue = values[j + 1]; 532 if (nextValue->isValueList()) 533 yValue = toCSSValueList(nextValue.get())->itemWithoutBoundsCheck(i); 534 else 535 yValue = nextValue; 536 537 // background-repeat-x(y) or mask-repeat-x(y) may be like this : "initial, repeat". We can omit the implicit initial values 538 // before starting to compare their values. 539 if (value->isImplicitInitialValue() || yValue->isImplicitInitialValue()) 540 continue; 541 542 // FIXME: At some point we need to fix this code to avoid returning an invalid shorthand, 543 // since some longhand combinations are not serializable into a single shorthand. 544 if (!value->isPrimitiveValue() || !yValue->isPrimitiveValue()) 545 continue; 546 547 CSSValueID xId = toCSSPrimitiveValue(value.get())->getValueID(); 548 CSSValueID yId = toCSSPrimitiveValue(yValue.get())->getValueID(); 549 if (xId != yId) { 550 if (xId == CSSValueRepeat && yId == CSSValueNoRepeat) { 551 useRepeatXShorthand = true; 552 ++j; 553 } else if (xId == CSSValueNoRepeat && yId == CSSValueRepeat) { 554 useRepeatYShorthand = true; 555 continue; 556 } 557 } else { 558 useSingleWordShorthand = true; 559 ++j; 560 } 561 } 562 } 563 564 String valueText; 565 if (value && !value->isImplicitInitialValue()) { 566 if (!layerResult.isEmpty()) 567 layerResult.append(' '); 568 if (foundPositionYCSSProperty 569 && (shorthand.properties()[j] == CSSPropertyBackgroundSize || shorthand.properties()[j] == CSSPropertyWebkitMaskSize)) 570 layerResult.appendLiteral("/ "); 571 if (!foundPositionYCSSProperty 572 && (shorthand.properties()[j] == CSSPropertyBackgroundSize || shorthand.properties()[j] == CSSPropertyWebkitMaskSize)) 573 continue; 574 575 if (useRepeatXShorthand) { 576 useRepeatXShorthand = false; 577 layerResult.append(getValueName(CSSValueRepeatX)); 578 } else if (useRepeatYShorthand) { 579 useRepeatYShorthand = false; 580 layerResult.append(getValueName(CSSValueRepeatY)); 581 } else { 582 if (useSingleWordShorthand) 583 useSingleWordShorthand = false; 584 valueText = value->cssText(); 585 layerResult.append(valueText); 586 } 587 588 if (shorthand.properties()[j] == CSSPropertyBackgroundPositionY 589 || shorthand.properties()[j] == CSSPropertyWebkitMaskPositionY) { 590 foundPositionYCSSProperty = true; 591 592 // background-position is a special case: if only the first offset is specified, 593 // the second one defaults to "center", not the same value. 594 if (commonValueInitialized && commonValue != "initial" && commonValue != "inherit") 595 commonValue = String(); 596 } 597 } 598 599 if (!commonValueInitialized) { 600 commonValue = valueText; 601 commonValueInitialized = true; 602 } else if (!commonValue.isNull() && commonValue != valueText) 603 commonValue = String(); 604 } 605 606 if (!layerResult.isEmpty()) { 607 if (!result.isEmpty()) 608 result.appendLiteral(", "); 609 result.append(layerResult); 610 } 611 } 612 613 if (isInitialOrInherit(commonValue)) 614 return commonValue; 615 616 if (result.isEmpty()) 617 return String(); 618 return result.toString(); 619 } 620 621 String StylePropertySerializer::getShorthandValue(const StylePropertyShorthand& shorthand) const 622 { 623 String commonValue; 624 StringBuilder result; 625 for (unsigned i = 0; i < shorthand.length(); ++i) { 626 if (!m_propertySet.isPropertyImplicit(shorthand.properties()[i])) { 627 RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]); 628 if (!value) 629 return String(); 630 String valueText = value->cssText(); 631 if (!i) 632 commonValue = valueText; 633 else if (!commonValue.isNull() && commonValue != valueText) 634 commonValue = String(); 635 if (value->isInitialValue()) 636 continue; 637 if (!result.isEmpty()) 638 result.append(' '); 639 result.append(valueText); 640 } else 641 commonValue = String(); 642 } 643 if (isInitialOrInherit(commonValue)) 644 return commonValue; 645 if (result.isEmpty()) 646 return String(); 647 return result.toString(); 648 } 649 650 // only returns a non-null value if all properties have the same, non-null value 651 String StylePropertySerializer::getCommonValue(const StylePropertyShorthand& shorthand) const 652 { 653 String res; 654 bool lastPropertyWasImportant = false; 655 for (unsigned i = 0; i < shorthand.length(); ++i) { 656 RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]); 657 // FIXME: CSSInitialValue::cssText should generate the right value. 658 if (!value) 659 return String(); 660 String text = value->cssText(); 661 if (text.isNull()) 662 return String(); 663 if (res.isNull()) 664 res = text; 665 else if (res != text) 666 return String(); 667 668 bool currentPropertyIsImportant = m_propertySet.propertyIsImportant(shorthand.properties()[i]); 669 if (i && lastPropertyWasImportant != currentPropertyIsImportant) 670 return String(); 671 lastPropertyWasImportant = currentPropertyIsImportant; 672 } 673 return res; 674 } 675 676 String StylePropertySerializer::borderPropertyValue(CommonValueMode valueMode) const 677 { 678 const StylePropertyShorthand properties[3] = { borderWidthShorthand(), borderStyleShorthand(), borderColorShorthand() }; 679 String commonValue; 680 StringBuilder result; 681 for (size_t i = 0; i < WTF_ARRAY_LENGTH(properties); ++i) { 682 String value = getCommonValue(properties[i]); 683 if (value.isNull()) { 684 if (valueMode == ReturnNullOnUncommonValues) 685 return String(); 686 ASSERT(valueMode == OmitUncommonValues); 687 continue; 688 } 689 if (!i) 690 commonValue = value; 691 else if (!commonValue.isNull() && commonValue != value) 692 commonValue = String(); 693 if (value == "initial") 694 continue; 695 if (!result.isEmpty()) 696 result.append(' '); 697 result.append(value); 698 } 699 if (isInitialOrInherit(commonValue)) 700 return commonValue; 701 return result.isEmpty() ? String() : result.toString(); 702 } 703 704 static void appendBackgroundRepeatValue(StringBuilder& builder, const CSSValue& repeatXCSSValue, const CSSValue& repeatYCSSValue) 705 { 706 // FIXME: Ensure initial values do not appear in CSS_VALUE_LISTS. 707 DEFINE_STATIC_REF_WILL_BE_PERSISTENT(CSSPrimitiveValue, initialRepeatValue, (CSSPrimitiveValue::create(CSSValueRepeat))); 708 const CSSPrimitiveValue& repeatX = repeatXCSSValue.isInitialValue() ? *initialRepeatValue : toCSSPrimitiveValue(repeatXCSSValue); 709 const CSSPrimitiveValue& repeatY = repeatYCSSValue.isInitialValue() ? *initialRepeatValue : toCSSPrimitiveValue(repeatYCSSValue); 710 CSSValueID repeatXValueId = repeatX.getValueID(); 711 CSSValueID repeatYValueId = repeatY.getValueID(); 712 if (repeatXValueId == repeatYValueId) { 713 builder.append(repeatX.cssText()); 714 } else if (repeatXValueId == CSSValueNoRepeat && repeatYValueId == CSSValueRepeat) { 715 builder.append("repeat-y"); 716 } else if (repeatXValueId == CSSValueRepeat && repeatYValueId == CSSValueNoRepeat) { 717 builder.append("repeat-x"); 718 } else { 719 builder.append(repeatX.cssText()); 720 builder.append(" "); 721 builder.append(repeatY.cssText()); 722 } 723 } 724 725 String StylePropertySerializer::backgroundRepeatPropertyValue() const 726 { 727 RefPtrWillBeRawPtr<CSSValue> repeatX = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatX); 728 RefPtrWillBeRawPtr<CSSValue> repeatY = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatY); 729 if (!repeatX || !repeatY) 730 return String(); 731 if (m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatX) != m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatY)) 732 return String(); 733 if (repeatX->cssValueType() == repeatY->cssValueType() 734 && (repeatX->cssValueType() == CSSValue::CSS_INITIAL || repeatX->cssValueType() == CSSValue::CSS_INHERIT)) { 735 return repeatX->cssText(); 736 } 737 738 RefPtrWillBeRawPtr<CSSValueList> repeatXList; 739 if (repeatX->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) { 740 repeatXList = CSSValueList::createCommaSeparated(); 741 repeatXList->append(repeatX); 742 } else if (repeatX->cssValueType() == CSSValue::CSS_VALUE_LIST) { 743 repeatXList = toCSSValueList(repeatX.get()); 744 } else { 745 return String(); 746 } 747 748 RefPtrWillBeRawPtr<CSSValueList> repeatYList; 749 if (repeatY->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) { 750 repeatYList = CSSValueList::createCommaSeparated(); 751 repeatYList->append(repeatY); 752 } else if (repeatY->cssValueType() == CSSValue::CSS_VALUE_LIST) { 753 repeatYList = toCSSValueList(repeatY.get()); 754 } else { 755 return String(); 756 } 757 758 size_t shorthandLength = lowestCommonMultiple(repeatXList->length(), repeatYList->length()); 759 StringBuilder builder; 760 for (size_t i = 0; i < shorthandLength; ++i) { 761 if (i) 762 builder.append(", "); 763 appendBackgroundRepeatValue(builder, 764 *repeatXList->item(i % repeatXList->length()), 765 *repeatYList->item(i % repeatYList->length())); 766 } 767 return builder.toString(); 768 } 769 770 void StylePropertySerializer::appendBackgroundPropertyAsText(StringBuilder& result, unsigned& numDecls) const 771 { 772 if (isPropertyShorthandAvailable(backgroundShorthand())) { 773 String backgroundValue = getPropertyValue(CSSPropertyBackground); 774 bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundImage); 775 result.append(getPropertyText(CSSPropertyBackground, backgroundValue, isImportant, numDecls++)); 776 return; 777 } 778 if (shorthandHasOnlyInitialOrInheritedValue(backgroundShorthand())) { 779 RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundImage); 780 bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundImage); 781 result.append(getPropertyText(CSSPropertyBackground, value->cssText(), isImportant, numDecls++)); 782 return; 783 } 784 785 // backgroundShorthandProperty without layered shorhand properties 786 const CSSPropertyID backgroundPropertyIds[] = { 787 CSSPropertyBackgroundImage, 788 CSSPropertyBackgroundAttachment, 789 CSSPropertyBackgroundColor, 790 CSSPropertyBackgroundSize, 791 CSSPropertyBackgroundOrigin, 792 CSSPropertyBackgroundClip 793 }; 794 795 for (unsigned i = 0; i < WTF_ARRAY_LENGTH(backgroundPropertyIds); ++i) { 796 CSSPropertyID propertyID = backgroundPropertyIds[i]; 797 RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(propertyID); 798 if (!value) 799 continue; 800 result.append(getPropertyText(propertyID, value->cssText(), m_propertySet.propertyIsImportant(propertyID), numDecls++)); 801 } 802 803 // FIXME: This is a not-so-nice way to turn x/y positions into single background-position in output. 804 // It is required because background-position-x/y are non-standard properties and WebKit generated output 805 // would not work in Firefox (<rdar://problem/5143183>) 806 // It would be a better solution if background-position was CSS_PAIR. 807 if (shorthandHasOnlyInitialOrInheritedValue(backgroundPositionShorthand())) { 808 RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionX); 809 bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX); 810 result.append(getPropertyText(CSSPropertyBackgroundPosition, value->cssText(), isImportant, numDecls++)); 811 } else if (isPropertyShorthandAvailable(backgroundPositionShorthand())) { 812 String positionValue = m_propertySet.getPropertyValue(CSSPropertyBackgroundPosition); 813 bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX); 814 if (!positionValue.isNull()) 815 result.append(getPropertyText(CSSPropertyBackgroundPosition, positionValue, isImportant, numDecls++)); 816 } else { 817 // should check background-position-x or background-position-y. 818 if (RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionX)) { 819 if (!value->isImplicitInitialValue()) { 820 bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX); 821 result.append(getPropertyText(CSSPropertyBackgroundPositionX, value->cssText(), isImportant, numDecls++)); 822 } 823 } 824 if (RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionY)) { 825 if (!value->isImplicitInitialValue()) { 826 bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionY); 827 result.append(getPropertyText(CSSPropertyBackgroundPositionY, value->cssText(), isImportant, numDecls++)); 828 } 829 } 830 } 831 832 String repeatValue = m_propertySet.getPropertyValue(CSSPropertyBackgroundRepeat); 833 if (!repeatValue.isNull()) 834 result.append(getPropertyText(CSSPropertyBackgroundRepeat, repeatValue, m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatX), numDecls++)); 835 } 836 837 bool StylePropertySerializer::isPropertyShorthandAvailable(const StylePropertyShorthand& shorthand) const 838 { 839 ASSERT(shorthand.length() > 0); 840 841 bool isImportant = m_propertySet.propertyIsImportant(shorthand.properties()[0]); 842 for (unsigned i = 0; i < shorthand.length(); ++i) { 843 RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]); 844 if (!value || (value->isInitialValue() && !value->isImplicitInitialValue()) || value->isInheritedValue()) 845 return false; 846 if (isImportant != m_propertySet.propertyIsImportant(shorthand.properties()[i])) 847 return false; 848 } 849 return true; 850 } 851 852 bool StylePropertySerializer::shorthandHasOnlyInitialOrInheritedValue(const StylePropertyShorthand& shorthand) const 853 { 854 ASSERT(shorthand.length() > 0); 855 bool isImportant = m_propertySet.propertyIsImportant(shorthand.properties()[0]); 856 bool isInitialValue = true; 857 bool isInheritedValue = true; 858 for (unsigned i = 0; i < shorthand.length(); ++i) { 859 RefPtrWillBeRawPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]); 860 if (!value) 861 return false; 862 if (!value->isInitialValue()) 863 isInitialValue = false; 864 if (!value->isInheritedValue()) 865 isInheritedValue = false; 866 if (isImportant != m_propertySet.propertyIsImportant(shorthand.properties()[i])) 867 return false; 868 } 869 return isInitialValue || isInheritedValue; 870 } 871 872 } 873
