1 /* 2 * (C) 1999-2003 Lars Knoll (knoll (at) kde.org) 3 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 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/StylePropertySet.h" 25 26 #include "core/StylePropertyShorthand.h" 27 #include "core/css/parser/BisonCSSParser.h" 28 #include "core/css/CSSValuePool.h" 29 #include "core/css/RuntimeCSSEnabled.h" 30 #include "core/css/StylePropertySerializer.h" 31 #include "core/css/StyleSheetContents.h" 32 #include "core/frame/UseCounter.h" 33 #include "platform/RuntimeEnabledFeatures.h" 34 #include "wtf/text/StringBuilder.h" 35 36 #ifndef NDEBUG 37 #include "wtf/text/CString.h" 38 #include <stdio.h> 39 #endif 40 41 namespace WebCore { 42 43 static size_t sizeForImmutableStylePropertySetWithPropertyCount(unsigned count) 44 { 45 return sizeof(ImmutableStylePropertySet) - sizeof(void*) + sizeof(CSSValue*) * count + sizeof(StylePropertyMetadata) * count; 46 } 47 48 PassRefPtr<ImmutableStylePropertySet> ImmutableStylePropertySet::create(const CSSProperty* properties, unsigned count, CSSParserMode cssParserMode) 49 { 50 ASSERT(count <= MaxArraySize); 51 #if ENABLE(OILPAN) 52 void* slot = Heap::allocate<StylePropertySet>(sizeForImmutableStylePropertySetWithPropertyCount(count)); 53 #else 54 void* slot = WTF::fastMalloc(sizeForImmutableStylePropertySetWithPropertyCount(count)); 55 #endif // ENABLE(OILPAN) 56 return adoptRefWillBeRefCountedGarbageCollected(new (slot) ImmutableStylePropertySet(properties, count, cssParserMode)); 57 } 58 59 PassRefPtr<ImmutableStylePropertySet> StylePropertySet::immutableCopyIfNeeded() const 60 { 61 if (!isMutable()) 62 return toImmutableStylePropertySet(const_cast<StylePropertySet*>(this)); 63 const MutableStylePropertySet* mutableThis = toMutableStylePropertySet(this); 64 return ImmutableStylePropertySet::create(mutableThis->m_propertyVector.data(), mutableThis->m_propertyVector.size(), cssParserMode()); 65 } 66 67 MutableStylePropertySet::MutableStylePropertySet(CSSParserMode cssParserMode) 68 : StylePropertySet(cssParserMode) 69 { 70 } 71 72 MutableStylePropertySet::MutableStylePropertySet(const CSSProperty* properties, unsigned length) 73 : StylePropertySet(HTMLStandardMode) 74 { 75 m_propertyVector.reserveInitialCapacity(length); 76 for (unsigned i = 0; i < length; ++i) 77 m_propertyVector.uncheckedAppend(properties[i]); 78 } 79 80 ImmutableStylePropertySet::ImmutableStylePropertySet(const CSSProperty* properties, unsigned length, CSSParserMode cssParserMode) 81 : StylePropertySet(cssParserMode, length) 82 { 83 StylePropertyMetadata* metadataArray = const_cast<StylePropertyMetadata*>(this->metadataArray()); 84 RawPtrWillBeMember<CSSValue>* valueArray = const_cast<RawPtrWillBeMember<CSSValue>*>(this->valueArray()); 85 for (unsigned i = 0; i < m_arraySize; ++i) { 86 metadataArray[i] = properties[i].metadata(); 87 valueArray[i] = properties[i].value(); 88 #if !ENABLE(OILPAN) 89 valueArray[i]->ref(); 90 #endif 91 } 92 } 93 94 ImmutableStylePropertySet::~ImmutableStylePropertySet() 95 { 96 #if !ENABLE(OILPAN) 97 RawPtrWillBeMember<CSSValue>* valueArray = const_cast<RawPtrWillBeMember<CSSValue>*>(this->valueArray()); 98 for (unsigned i = 0; i < m_arraySize; ++i) 99 valueArray[i]->deref(); 100 #endif 101 } 102 103 int ImmutableStylePropertySet::findPropertyIndex(CSSPropertyID propertyID) const 104 { 105 // Convert here propertyID into an uint16_t to compare it with the metadata's m_propertyID to avoid 106 // the compiler converting it to an int multiple times in the loop. 107 uint16_t id = static_cast<uint16_t>(propertyID); 108 for (int n = m_arraySize - 1 ; n >= 0; --n) { 109 if (metadataArray()[n].m_propertyID == id) { 110 // Only enabled or internal properties should be part of the style. 111 ASSERT(RuntimeCSSEnabled::isCSSPropertyEnabled(propertyID) || isInternalProperty(propertyID)); 112 return n; 113 } 114 } 115 116 return -1; 117 } 118 119 void ImmutableStylePropertySet::traceAfterDispatch(Visitor* visitor) 120 { 121 const RawPtrWillBeMember<CSSValue>* values = valueArray(); 122 for (unsigned i = 0; i < m_arraySize; i++) 123 visitor->trace(values[i]); 124 StylePropertySet::traceAfterDispatch(visitor); 125 } 126 127 MutableStylePropertySet::MutableStylePropertySet(const StylePropertySet& other) 128 : StylePropertySet(other.cssParserMode()) 129 { 130 if (other.isMutable()) { 131 m_propertyVector = toMutableStylePropertySet(other).m_propertyVector; 132 } else { 133 m_propertyVector.reserveInitialCapacity(other.propertyCount()); 134 for (unsigned i = 0; i < other.propertyCount(); ++i) 135 m_propertyVector.uncheckedAppend(other.propertyAt(i).toCSSProperty()); 136 } 137 } 138 139 String StylePropertySet::getPropertyValue(CSSPropertyID propertyID) const 140 { 141 RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(propertyID); 142 if (value) 143 return value->cssText(); 144 145 return StylePropertySerializer(*this).getPropertyValue(propertyID); 146 } 147 148 PassRefPtrWillBeRawPtr<CSSValue> StylePropertySet::getPropertyCSSValue(CSSPropertyID propertyID) const 149 { 150 int foundPropertyIndex = findPropertyIndex(propertyID); 151 if (foundPropertyIndex == -1) 152 return nullptr; 153 return propertyAt(foundPropertyIndex).value(); 154 } 155 156 void StylePropertySet::trace(Visitor* visitor) 157 { 158 if (m_isMutable) 159 toMutableStylePropertySet(this)->traceAfterDispatch(visitor); 160 else 161 toImmutableStylePropertySet(this)->traceAfterDispatch(visitor); 162 } 163 164 #if ENABLE(OILPAN) 165 void StylePropertySet::finalizeGarbageCollectedObject() 166 { 167 if (m_isMutable) 168 toMutableStylePropertySet(this)->~MutableStylePropertySet(); 169 else 170 toImmutableStylePropertySet(this)->~ImmutableStylePropertySet(); 171 } 172 #endif 173 174 bool MutableStylePropertySet::removeShorthandProperty(CSSPropertyID propertyID) 175 { 176 StylePropertyShorthand shorthand = shorthandForProperty(propertyID); 177 if (!shorthand.length()) 178 return false; 179 180 bool ret = removePropertiesInSet(shorthand.properties(), shorthand.length()); 181 182 CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(propertyID); 183 if (prefixingVariant == propertyID) 184 return ret; 185 186 StylePropertyShorthand shorthandPrefixingVariant = shorthandForProperty(prefixingVariant); 187 return removePropertiesInSet(shorthandPrefixingVariant.properties(), shorthandPrefixingVariant.length()); 188 } 189 190 bool MutableStylePropertySet::removeProperty(CSSPropertyID propertyID, String* returnText) 191 { 192 if (removeShorthandProperty(propertyID)) { 193 // FIXME: Return an equivalent shorthand when possible. 194 if (returnText) 195 *returnText = ""; 196 return true; 197 } 198 199 int foundPropertyIndex = findPropertyIndex(propertyID); 200 if (foundPropertyIndex == -1) { 201 if (returnText) 202 *returnText = ""; 203 return false; 204 } 205 206 if (returnText) 207 *returnText = propertyAt(foundPropertyIndex).value()->cssText(); 208 209 // A more efficient removal strategy would involve marking entries as empty 210 // and sweeping them when the vector grows too big. 211 m_propertyVector.remove(foundPropertyIndex); 212 213 removePrefixedOrUnprefixedProperty(propertyID); 214 215 return true; 216 } 217 218 void MutableStylePropertySet::removePrefixedOrUnprefixedProperty(CSSPropertyID propertyID) 219 { 220 int foundPropertyIndex = findPropertyIndex(prefixingVariantForPropertyId(propertyID)); 221 if (foundPropertyIndex == -1) 222 return; 223 m_propertyVector.remove(foundPropertyIndex); 224 } 225 226 bool StylePropertySet::propertyIsImportant(CSSPropertyID propertyID) const 227 { 228 int foundPropertyIndex = findPropertyIndex(propertyID); 229 if (foundPropertyIndex != -1) 230 return propertyAt(foundPropertyIndex).isImportant(); 231 232 StylePropertyShorthand shorthand = shorthandForProperty(propertyID); 233 if (!shorthand.length()) 234 return false; 235 236 for (unsigned i = 0; i < shorthand.length(); ++i) { 237 if (!propertyIsImportant(shorthand.properties()[i])) 238 return false; 239 } 240 return true; 241 } 242 243 CSSPropertyID StylePropertySet::getPropertyShorthand(CSSPropertyID propertyID) const 244 { 245 int foundPropertyIndex = findPropertyIndex(propertyID); 246 if (foundPropertyIndex == -1) 247 return CSSPropertyInvalid; 248 return propertyAt(foundPropertyIndex).shorthandID(); 249 } 250 251 bool StylePropertySet::isPropertyImplicit(CSSPropertyID propertyID) const 252 { 253 int foundPropertyIndex = findPropertyIndex(propertyID); 254 if (foundPropertyIndex == -1) 255 return false; 256 return propertyAt(foundPropertyIndex).isImplicit(); 257 } 258 259 bool MutableStylePropertySet::setProperty(CSSPropertyID propertyID, const String& value, bool important, StyleSheetContents* contextStyleSheet) 260 { 261 // Setting the value to an empty string just removes the property in both IE and Gecko. 262 // Setting it to null seems to produce less consistent results, but we treat it just the same. 263 if (value.isEmpty()) 264 return removeProperty(propertyID); 265 266 // When replacing an existing property value, this moves the property to the end of the list. 267 // Firefox preserves the position, and MSIE moves the property to the beginning. 268 return BisonCSSParser::parseValue(this, propertyID, value, important, cssParserMode(), contextStyleSheet); 269 } 270 271 void MutableStylePropertySet::setProperty(CSSPropertyID propertyID, PassRefPtrWillBeRawPtr<CSSValue> prpValue, bool important) 272 { 273 StylePropertyShorthand shorthand = shorthandForProperty(propertyID); 274 if (!shorthand.length()) { 275 setProperty(CSSProperty(propertyID, prpValue, important)); 276 return; 277 } 278 279 removePropertiesInSet(shorthand.properties(), shorthand.length()); 280 281 RefPtrWillBeRawPtr<CSSValue> value = prpValue; 282 for (unsigned i = 0; i < shorthand.length(); ++i) 283 m_propertyVector.append(CSSProperty(shorthand.properties()[i], value, important)); 284 } 285 286 void MutableStylePropertySet::setProperty(const CSSProperty& property, CSSProperty* slot) 287 { 288 if (!removeShorthandProperty(property.id())) { 289 CSSProperty* toReplace = slot ? slot : findCSSPropertyWithID(property.id()); 290 if (toReplace) { 291 *toReplace = property; 292 setPrefixingVariantProperty(property); 293 return; 294 } 295 } 296 appendPrefixingVariantProperty(property); 297 } 298 299 unsigned getIndexInShorthandVectorForPrefixingVariant(const CSSProperty& property, CSSPropertyID prefixingVariant) 300 { 301 if (!property.isSetFromShorthand()) 302 return 0; 303 304 CSSPropertyID prefixedShorthand = prefixingVariantForPropertyId(property.shorthandID()); 305 Vector<StylePropertyShorthand, 4> shorthands; 306 getMatchingShorthandsForLonghand(prefixingVariant, &shorthands); 307 return indexOfShorthandForLonghand(prefixedShorthand, shorthands); 308 } 309 310 void MutableStylePropertySet::appendPrefixingVariantProperty(const CSSProperty& property) 311 { 312 m_propertyVector.append(property); 313 CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(property.id()); 314 if (prefixingVariant == property.id()) 315 return; 316 317 m_propertyVector.append(CSSProperty(prefixingVariant, property.value(), property.isImportant(), property.isSetFromShorthand(), getIndexInShorthandVectorForPrefixingVariant(property, prefixingVariant), property.metadata().m_implicit)); 318 } 319 320 void MutableStylePropertySet::setPrefixingVariantProperty(const CSSProperty& property) 321 { 322 CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(property.id()); 323 CSSProperty* toReplace = findCSSPropertyWithID(prefixingVariant); 324 if (toReplace && prefixingVariant != property.id()) 325 *toReplace = CSSProperty(prefixingVariant, property.value(), property.isImportant(), property.isSetFromShorthand(), getIndexInShorthandVectorForPrefixingVariant(property, prefixingVariant), property.metadata().m_implicit); 326 } 327 328 bool MutableStylePropertySet::setProperty(CSSPropertyID propertyID, CSSValueID identifier, bool important) 329 { 330 setProperty(CSSProperty(propertyID, cssValuePool().createIdentifierValue(identifier), important)); 331 return true; 332 } 333 334 bool MutableStylePropertySet::setProperty(CSSPropertyID propertyID, CSSPropertyID identifier, bool important) 335 { 336 setProperty(CSSProperty(propertyID, cssValuePool().createIdentifierValue(identifier), important)); 337 return true; 338 } 339 340 void MutableStylePropertySet::parseDeclaration(const String& styleDeclaration, StyleSheetContents* contextStyleSheet) 341 { 342 m_propertyVector.clear(); 343 344 CSSParserContext context(cssParserMode(), UseCounter::getFrom(contextStyleSheet)); 345 if (contextStyleSheet) { 346 context = contextStyleSheet->parserContext(); 347 context.setMode(cssParserMode()); 348 } 349 350 BisonCSSParser parser(context); 351 parser.parseDeclaration(this, styleDeclaration, 0, contextStyleSheet); 352 } 353 354 void MutableStylePropertySet::addParsedProperties(const WillBeHeapVector<CSSProperty, 256>& properties) 355 { 356 m_propertyVector.reserveCapacity(m_propertyVector.size() + properties.size()); 357 for (unsigned i = 0; i < properties.size(); ++i) 358 addParsedProperty(properties[i]); 359 } 360 361 void MutableStylePropertySet::addParsedProperty(const CSSProperty& property) 362 { 363 // Only add properties that have no !important counterpart present 364 if (!propertyIsImportant(property.id()) || property.isImportant()) 365 setProperty(property); 366 } 367 368 String StylePropertySet::asText() const 369 { 370 return StylePropertySerializer(*this).asText(); 371 } 372 373 void MutableStylePropertySet::mergeAndOverrideOnConflict(const StylePropertySet* other) 374 { 375 unsigned size = other->propertyCount(); 376 for (unsigned n = 0; n < size; ++n) { 377 PropertyReference toMerge = other->propertyAt(n); 378 CSSProperty* old = findCSSPropertyWithID(toMerge.id()); 379 if (old) 380 setProperty(toMerge.toCSSProperty(), old); 381 else 382 appendPrefixingVariantProperty(toMerge.toCSSProperty()); 383 } 384 } 385 386 bool StylePropertySet::hasFailedOrCanceledSubresources() const 387 { 388 unsigned size = propertyCount(); 389 for (unsigned i = 0; i < size; ++i) { 390 if (propertyAt(i).value()->hasFailedOrCanceledSubresources()) 391 return true; 392 } 393 return false; 394 } 395 396 // This is the list of properties we want to copy in the copyBlockProperties() function. 397 // It is the list of CSS properties that apply specially to block-level elements. 398 static const CSSPropertyID staticBlockProperties[] = { 399 CSSPropertyOrphans, 400 CSSPropertyOverflow, // This can be also be applied to replaced elements 401 CSSPropertyWebkitAspectRatio, 402 CSSPropertyWebkitColumnCount, 403 CSSPropertyWebkitColumnGap, 404 CSSPropertyWebkitColumnRuleColor, 405 CSSPropertyWebkitColumnRuleStyle, 406 CSSPropertyWebkitColumnRuleWidth, 407 CSSPropertyWebkitColumnBreakBefore, 408 CSSPropertyWebkitColumnBreakAfter, 409 CSSPropertyWebkitColumnBreakInside, 410 CSSPropertyWebkitColumnWidth, 411 CSSPropertyPageBreakAfter, 412 CSSPropertyPageBreakBefore, 413 CSSPropertyPageBreakInside, 414 CSSPropertyTextAlign, 415 CSSPropertyTextAlignLast, 416 CSSPropertyTextIndent, 417 CSSPropertyTextJustify, 418 CSSPropertyWidows 419 }; 420 421 static const Vector<CSSPropertyID>& blockProperties() 422 { 423 DEFINE_STATIC_LOCAL(Vector<CSSPropertyID>, properties, ()); 424 if (properties.isEmpty()) 425 RuntimeCSSEnabled::filterEnabledCSSPropertiesIntoVector(staticBlockProperties, WTF_ARRAY_LENGTH(staticBlockProperties), properties); 426 return properties; 427 } 428 429 void MutableStylePropertySet::clear() 430 { 431 m_propertyVector.clear(); 432 } 433 434 PassRefPtrWillBeRawPtr<MutableStylePropertySet> StylePropertySet::copyBlockProperties() const 435 { 436 return copyPropertiesInSet(blockProperties()); 437 } 438 439 void MutableStylePropertySet::removeBlockProperties() 440 { 441 removePropertiesInSet(blockProperties().data(), blockProperties().size()); 442 } 443 444 inline bool containsId(const CSSPropertyID* set, unsigned length, CSSPropertyID id) 445 { 446 for (unsigned i = 0; i < length; ++i) { 447 if (set[i] == id) 448 return true; 449 } 450 return false; 451 } 452 453 bool MutableStylePropertySet::removePropertiesInSet(const CSSPropertyID* set, unsigned length) 454 { 455 if (m_propertyVector.isEmpty()) 456 return false; 457 458 WillBeHeapVector<CSSProperty> newProperties; 459 newProperties.reserveInitialCapacity(m_propertyVector.size()); 460 461 unsigned initialSize = m_propertyVector.size(); 462 const CSSProperty* properties = m_propertyVector.data(); 463 for (unsigned n = 0; n < initialSize; ++n) { 464 const CSSProperty& property = properties[n]; 465 // Not quite sure if the isImportant test is needed but it matches the existing behavior. 466 if (!property.isImportant() && containsId(set, length, property.id())) 467 continue; 468 newProperties.append(property); 469 } 470 471 m_propertyVector = newProperties; 472 return initialSize != m_propertyVector.size(); 473 } 474 475 CSSProperty* MutableStylePropertySet::findCSSPropertyWithID(CSSPropertyID propertyID) 476 { 477 int foundPropertyIndex = findPropertyIndex(propertyID); 478 if (foundPropertyIndex == -1) 479 return 0; 480 return &m_propertyVector.at(foundPropertyIndex); 481 } 482 483 bool StylePropertySet::propertyMatches(CSSPropertyID propertyID, const CSSValue* propertyValue) const 484 { 485 int foundPropertyIndex = findPropertyIndex(propertyID); 486 if (foundPropertyIndex == -1) 487 return false; 488 return propertyAt(foundPropertyIndex).value()->equals(*propertyValue); 489 } 490 491 void MutableStylePropertySet::removeEquivalentProperties(const StylePropertySet* style) 492 { 493 Vector<CSSPropertyID> propertiesToRemove; 494 unsigned size = m_propertyVector.size(); 495 for (unsigned i = 0; i < size; ++i) { 496 PropertyReference property = propertyAt(i); 497 if (style->propertyMatches(property.id(), property.value())) 498 propertiesToRemove.append(property.id()); 499 } 500 // FIXME: This should use mass removal. 501 for (unsigned i = 0; i < propertiesToRemove.size(); ++i) 502 removeProperty(propertiesToRemove[i]); 503 } 504 505 void MutableStylePropertySet::removeEquivalentProperties(const CSSStyleDeclaration* style) 506 { 507 Vector<CSSPropertyID> propertiesToRemove; 508 unsigned size = m_propertyVector.size(); 509 for (unsigned i = 0; i < size; ++i) { 510 PropertyReference property = propertyAt(i); 511 if (style->cssPropertyMatches(property.id(), property.value())) 512 propertiesToRemove.append(property.id()); 513 } 514 // FIXME: This should use mass removal. 515 for (unsigned i = 0; i < propertiesToRemove.size(); ++i) 516 removeProperty(propertiesToRemove[i]); 517 } 518 519 PassRefPtrWillBeRawPtr<MutableStylePropertySet> StylePropertySet::mutableCopy() const 520 { 521 return adoptRefWillBeRefCountedGarbageCollected(new MutableStylePropertySet(*this)); 522 } 523 524 PassRefPtrWillBeRawPtr<MutableStylePropertySet> StylePropertySet::copyPropertiesInSet(const Vector<CSSPropertyID>& properties) const 525 { 526 WillBeHeapVector<CSSProperty, 256> list; 527 list.reserveInitialCapacity(properties.size()); 528 for (unsigned i = 0; i < properties.size(); ++i) { 529 RefPtrWillBeRawPtr<CSSValue> value = getPropertyCSSValue(properties[i]); 530 if (value) 531 list.append(CSSProperty(properties[i], value.release(), false)); 532 } 533 return MutableStylePropertySet::create(list.data(), list.size()); 534 } 535 536 CSSStyleDeclaration* MutableStylePropertySet::ensureCSSStyleDeclaration() 537 { 538 // FIXME: get rid of this weirdness of a CSSStyleDeclaration inside of a 539 // style property set. 540 if (m_cssomWrapper) { 541 ASSERT(!static_cast<CSSStyleDeclaration*>(m_cssomWrapper.get())->parentRule()); 542 ASSERT(!m_cssomWrapper->parentElement()); 543 return m_cssomWrapper.get(); 544 } 545 m_cssomWrapper = adoptPtrWillBeNoop(new PropertySetCSSStyleDeclaration(*this)); 546 return m_cssomWrapper.get(); 547 } 548 549 int MutableStylePropertySet::findPropertyIndex(CSSPropertyID propertyID) const 550 { 551 // Convert here propertyID into an uint16_t to compare it with the metadata's m_propertyID to avoid 552 // the compiler converting it to an int multiple times in the loop. 553 uint16_t id = static_cast<uint16_t>(propertyID); 554 const CSSProperty* properties = m_propertyVector.data(); 555 for (int n = m_propertyVector.size() - 1 ; n >= 0; --n) { 556 if (properties[n].metadata().m_propertyID == id) { 557 // Only enabled or internal properties should be part of the style. 558 ASSERT(RuntimeCSSEnabled::isCSSPropertyEnabled(propertyID) || isInternalProperty(propertyID)); 559 return n; 560 } 561 } 562 563 return -1; 564 } 565 566 void MutableStylePropertySet::traceAfterDispatch(Visitor* visitor) 567 { 568 visitor->trace(m_cssomWrapper); 569 visitor->trace(m_propertyVector); 570 StylePropertySet::traceAfterDispatch(visitor); 571 } 572 573 unsigned StylePropertySet::averageSizeInBytes() 574 { 575 // Please update this if the storage scheme changes so that this longer reflects the actual size. 576 return sizeForImmutableStylePropertySetWithPropertyCount(4); 577 } 578 579 // See the function above if you need to update this. 580 struct SameSizeAsStylePropertySet : public RefCountedWillBeRefCountedGarbageCollected<SameSizeAsStylePropertySet> { 581 unsigned bitfield; 582 }; 583 COMPILE_ASSERT(sizeof(StylePropertySet) == sizeof(SameSizeAsStylePropertySet), style_property_set_should_stay_small); 584 585 #ifndef NDEBUG 586 void StylePropertySet::showStyle() 587 { 588 fprintf(stderr, "%s\n", asText().ascii().data()); 589 } 590 #endif 591 592 PassRefPtrWillBeRawPtr<MutableStylePropertySet> MutableStylePropertySet::create(CSSParserMode cssParserMode) 593 { 594 return adoptRefWillBeRefCountedGarbageCollected(new MutableStylePropertySet(cssParserMode)); 595 } 596 597 PassRefPtrWillBeRawPtr<MutableStylePropertySet> MutableStylePropertySet::create(const CSSProperty* properties, unsigned count) 598 { 599 return adoptRefWillBeRefCountedGarbageCollected(new MutableStylePropertySet(properties, count)); 600 } 601 602 String StylePropertySet::PropertyReference::cssName() const 603 { 604 return getPropertyNameString(id()); 605 } 606 607 String StylePropertySet::PropertyReference::cssText() const 608 { 609 StringBuilder result; 610 result.append(cssName()); 611 result.appendLiteral(": "); 612 result.append(propertyValue()->cssText()); 613 if (isImportant()) 614 result.appendLiteral(" !important"); 615 result.append(';'); 616 return result.toString(); 617 } 618 619 620 } // namespace WebCore 621