Source/WebCore/dom/StyledElement.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Peter Kelly (pmk@post.com)
   5  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   6  * Copyright (C) 2004, 2005, 2006, 2008, 2010 Apple 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 Library 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  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #include "config.h"
  25 #include "StyledElement.h"
  26
  27 #include "Attribute.h"
  28 #include "CSSImageValue.h"
  29 #include "CSSParser.h"
  30 #include "CSSPropertyNames.h"
  31 #include "CSSStyleSheet.h"
  32 #include "CSSValueKeywords.h"
  33 #include "CSSValuePool.h"
  34 #include "Color.h"
  35 #include "ClassList.h"
  36 #include "ContentSecurityPolicy.h"
  37 #include "DOMTokenList.h"
  38 #include "Document.h"
  39 #include "HTMLNames.h"
  40 #include "HTMLParserIdioms.h"
  41 #include "PropertySetCSSStyleDeclaration.h"
  42 #include "ScriptableDocumentParser.h"
  43 #include "StylePropertySet.h"
  44 #include "StyleResolver.h"
  45 #include <wtf/HashFunctions.h>
  46 #include <wtf/text/TextPosition.h>
  47
  48 using namespace std;
  49
  50 namespace WebCore {
  51
  52 COMPILE_ASSERT(sizeof(StyledElement) == sizeof(Element), styledelement_should_remain_same_size_as_element);
  53
  54 using namespace HTMLNames;
  55
  56 struct PresentationAttributeCacheKey {
  57     PresentationAttributeCacheKey() : tagName(0) { }
  58     AtomicStringImpl* tagName;
  59     // Only the values need refcounting.
  60     Vector<pair<AtomicStringImpl*, AtomicString>, 3> attributesAndValues;
  61 };
  62
  63 struct PresentationAttributeCacheEntry {
  64     WTF_MAKE_FAST_ALLOCATED;
  65 public:
  66     PresentationAttributeCacheKey key;
  67     RefPtr<StylePropertySet> value;
  68 };
  69
  70 typedef HashMap<unsigned, OwnPtr<PresentationAttributeCacheEntry>, AlreadyHashed> PresentationAttributeCache;
  71
  72 static bool operator!=(const PresentationAttributeCacheKey& a, const PresentationAttributeCacheKey& b)
  73 {
  74     if (a.tagName != b.tagName)
  75         return true;
  76     return a.attributesAndValues != b.attributesAndValues;
  77 }
  78
  79 static PresentationAttributeCache& presentationAttributeCache()
  80 {
  81     DEFINE_STATIC_LOCAL(PresentationAttributeCache, cache, ());
  82     return cache;
  83 }
  84
  85 class PresentationAttributeCacheCleaner {
  86     WTF_MAKE_NONCOPYABLE(PresentationAttributeCacheCleaner); WTF_MAKE_FAST_ALLOCATED;
  87 public:
  88     PresentationAttributeCacheCleaner()
  89         : m_cleanTimer(this, &PresentationAttributeCacheCleaner::cleanCache)
  90     {
  91     }
  92
  93     void didHitPresentationAttributeCache()
  94     {
  95         if (presentationAttributeCache().size() < minimumPresentationAttributeCacheSizeForCleaning)
  96             return;
  97
  98         m_hitCount++;
  99
 100         if (!m_cleanTimer.isActive())
 101             m_cleanTimer.startOneShot(presentationAttributeCacheCleanTimeInSeconds);
 102      }
 103
 104 private:
 105     static const unsigned presentationAttributeCacheCleanTimeInSeconds = 60;
 106     static const int minimumPresentationAttributeCacheSizeForCleaning = 100;
 107     static const unsigned minimumPresentationAttributeCacheHitCountPerMinute = (100 * presentationAttributeCacheCleanTimeInSeconds) / 60;
 108
 109     void cleanCache(Timer<PresentationAttributeCacheCleaner>* timer)
 110     {
 111         ASSERT_UNUSED(timer, timer == &m_cleanTimer);
 112         unsigned hitCount = m_hitCount;
 113         m_hitCount = 0;
 114         if (hitCount > minimumPresentationAttributeCacheHitCountPerMinute)
 115             return;
 116         presentationAttributeCache().clear();
 117     }
 118
 119     unsigned m_hitCount;
 120     Timer<PresentationAttributeCacheCleaner> m_cleanTimer;
 121 };
 122
 123 static PresentationAttributeCacheCleaner& presentationAttributeCacheCleaner()
 124 {
 125     DEFINE_STATIC_LOCAL(PresentationAttributeCacheCleaner, cleaner, ());
 126     return cleaner;
 127 }
 128
 129 void StyledElement::synchronizeStyleAttributeInternal() const
 130 {
 131     ASSERT(elementData());
 132     ASSERT(elementData()->m_styleAttributeIsDirty);
 133     elementData()->m_styleAttributeIsDirty = false;
 134     if (const StylePropertySet* inlineStyle = this->inlineStyle())
 135         const_cast<StyledElement*>(this)->setSynchronizedLazyAttribute(styleAttr, inlineStyle->asText());
 136 }
 137
 138 StyledElement::~StyledElement()
 139 {
 140     if (PropertySetCSSStyleDeclaration* cssomWrapper = inlineStyleCSSOMWrapper())
 141         cssomWrapper->clearParentElement();
 142 }
 143
 144 CSSStyleDeclaration* StyledElement::style()
 145 {
 146     return ensureMutableInlineStyle()->ensureInlineCSSStyleDeclaration(this);
 147 }
 148
 149 MutableStylePropertySet* StyledElement::ensureMutableInlineStyle()
 150 {
 151     RefPtr<StylePropertySet>& inlineStyle = ensureUniqueElementData()->m_inlineStyle;
 152     if (!inlineStyle)
 153         inlineStyle = MutableStylePropertySet::create(strictToCSSParserMode(isHTMLElement() && !document()->inQuirksMode()));
 154     else if (!inlineStyle->isMutable())
 155         inlineStyle = inlineStyle->mutableCopy();
 156     ASSERT(inlineStyle->isMutable());
 157     return static_cast<MutableStylePropertySet*>(inlineStyle.get());
 158 }
 159
 160 void StyledElement::attributeChanged(const QualifiedName& name, const AtomicString& newValue, AttributeModificationReason reason)
 161 {
 162     if (name == styleAttr)
 163         styleAttributeChanged(newValue, reason);
 164     else if (isPresentationAttribute(name)) {
 165         elementData()->m_presentationAttributeStyleIsDirty = true;
 166         setNeedsStyleRecalc(InlineStyleChange);
 167     }
 168
 169     Element::attributeChanged(name, newValue, reason);
 170 }
 171
 172 PropertySetCSSStyleDeclaration* StyledElement::inlineStyleCSSOMWrapper()
 173 {
 174     if (!inlineStyle() || !inlineStyle()->hasCSSOMWrapper())
 175         return 0;
 176     PropertySetCSSStyleDeclaration* cssomWrapper = ensureMutableInlineStyle()->cssStyleDeclaration();
 177     ASSERT(cssomWrapper && cssomWrapper->parentElement() == this);
 178     return cssomWrapper;
 179 }
 180
 181 inline void StyledElement::setInlineStyleFromString(const AtomicString& newStyleString)
 182 {
 183     RefPtr<StylePropertySet>& inlineStyle = elementData()->m_inlineStyle;
 184
 185     // Avoid redundant work if we're using shared attribute data with already parsed inline style.
 186     if (inlineStyle && !elementData()->isUnique())
 187         return;
 188
 189     // We reconstruct the property set instead of mutating if there is no CSSOM wrapper.
 190     // This makes wrapperless property sets immutable and so cacheable.
 191     if (inlineStyle && !inlineStyle->isMutable())
 192         inlineStyle.clear();
 193
 194     if (!inlineStyle)
 195         inlineStyle = CSSParser::parseInlineStyleDeclaration(newStyleString, this);
 196     else {
 197         ASSERT(inlineStyle->isMutable());
 198         static_pointer_cast<MutableStylePropertySet>(inlineStyle)->parseDeclaration(newStyleString, document()->elementSheet()->contents());
 199     }
 200 }
 201
 202 void StyledElement::styleAttributeChanged(const AtomicString& newStyleString, AttributeModificationReason reason)
 203 {
 204     WTF::OrdinalNumber startLineNumber = WTF::OrdinalNumber::beforeFirst();
 205     if (document() && document()->scriptableDocumentParser() && !document()->isInDocumentWrite())
 206         startLineNumber = document()->scriptableDocumentParser()->lineNumber();
 207
 208     if (newStyleString.isNull()) {
 209         if (PropertySetCSSStyleDeclaration* cssomWrapper = inlineStyleCSSOMWrapper())
 210             cssomWrapper->clearParentElement();
 211         ensureUniqueElementData()->m_inlineStyle.clear();
 212     } else if (reason == ModifiedByCloning || document()->contentSecurityPolicy()->allowInlineStyle(document()->url(), startLineNumber))
 213         setInlineStyleFromString(newStyleString);
 214
 215     elementData()->m_styleAttributeIsDirty = false;
 216
 217     setNeedsStyleRecalc(InlineStyleChange);
 218     InspectorInstrumentation::didInvalidateStyleAttr(document(), this);
 219 }
 220
 221 void StyledElement::inlineStyleChanged()
 222 {
 223     setNeedsStyleRecalc(InlineStyleChange);
 224     ASSERT(elementData());
 225     elementData()->m_styleAttributeIsDirty = true;
 226     InspectorInstrumentation::didInvalidateStyleAttr(document(), this);
 227 }
 228
 229 bool StyledElement::setInlineStyleProperty(CSSPropertyID propertyID, int identifier, bool important)
 230 {
 231     ensureMutableInlineStyle()->setProperty(propertyID, cssValuePool().createIdentifierValue(identifier), important);
 232     inlineStyleChanged();
 233     return true;
 234 }
 235
 236 bool StyledElement::setInlineStyleProperty(CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitTypes unit, bool important)
 237 {
 238     ensureMutableInlineStyle()->setProperty(propertyID, cssValuePool().createValue(value, unit), important);
 239     inlineStyleChanged();
 240     return true;
 241 }
 242
 243 bool StyledElement::setInlineStyleProperty(CSSPropertyID propertyID, const String& value, bool important)
 244 {
 245     bool changes = ensureMutableInlineStyle()->setProperty(propertyID, value, important, document()->elementSheet()->contents());
 246     if (changes)
 247         inlineStyleChanged();
 248     return changes;
 249 }
 250
 251 bool StyledElement::removeInlineStyleProperty(CSSPropertyID propertyID)
 252 {
 253     if (!inlineStyle())
 254         return false;
 255     bool changes = ensureMutableInlineStyle()->removeProperty(propertyID);
 256     if (changes)
 257         inlineStyleChanged();
 258     return changes;
 259 }
 260
 261 void StyledElement::removeAllInlineStyleProperties()
 262 {
 263     if (!inlineStyle() || inlineStyle()->isEmpty())
 264         return;
 265     ensureMutableInlineStyle()->clear();
 266     inlineStyleChanged();
 267 }
 268
 269 void StyledElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
 270 {
 271     if (const StylePropertySet* inlineStyle = elementData() ? elementData()->inlineStyle() : 0)
 272         inlineStyle->addSubresourceStyleURLs(urls, document()->elementSheet()->contents());
 273 }
 274
 275 static inline bool attributeNameSort(const pair<AtomicStringImpl*, AtomicString>& p1, const pair<AtomicStringImpl*, AtomicString>& p2)
 276 {
 277     // Sort based on the attribute name pointers. It doesn't matter what the order is as long as it is always the same.
 278     return p1.first < p2.first;
 279 }
 280
 281 void StyledElement::makePresentationAttributeCacheKey(PresentationAttributeCacheKey& result) const
 282 {
 283     // FIXME: Enable for SVG.
 284     if (namespaceURI() != xhtmlNamespaceURI)
 285         return;
 286     // Interpretation of the size attributes on <input> depends on the type attribute.
 287     if (hasTagName(inputTag))
 288         return;
 289     unsigned size = attributeCount();
 290     for (unsigned i = 0; i < size; ++i) {
 291         const Attribute* attribute = attributeItem(i);
 292         if (!isPresentationAttribute(attribute->name()))
 293             continue;
 294         if (!attribute->namespaceURI().isNull())
 295             return;
 296         // FIXME: Background URL may depend on the base URL and can't be shared. Disallow caching.
 297         if (attribute->name() == backgroundAttr)
 298             return;
 299         result.attributesAndValues.append(make_pair(attribute->localName().impl(), attribute->value()));
 300     }
 301     if (result.attributesAndValues.isEmpty())
 302         return;
 303     // Attribute order doesn't matter. Sort for easy equality comparison.
 304     std::sort(result.attributesAndValues.begin(), result.attributesAndValues.end(), attributeNameSort);
 305     // The cache key is non-null when the tagName is set.
 306     result.tagName = localName().impl();
 307 }
 308
 309 static unsigned computePresentationAttributeCacheHash(const PresentationAttributeCacheKey& key)
 310 {
 311     if (!key.tagName)
 312         return 0;
 313     ASSERT(key.attributesAndValues.size());
 314     unsigned attributeHash = StringHasher::hashMemory(key.attributesAndValues.data(), key.attributesAndValues.size() * sizeof(key.attributesAndValues[0]));
 315     return WTF::pairIntHash(key.tagName->existingHash(), attributeHash);
 316 }
 317
 318 void StyledElement::rebuildPresentationAttributeStyle()
 319 {
 320     PresentationAttributeCacheKey cacheKey;
 321     makePresentationAttributeCacheKey(cacheKey);
 322
 323     unsigned cacheHash = computePresentationAttributeCacheHash(cacheKey);
 324
 325     PresentationAttributeCache::iterator cacheIterator;
 326     if (cacheHash) {
 327         cacheIterator = presentationAttributeCache().add(cacheHash, nullptr).iterator;
 328         if (cacheIterator->value && cacheIterator->value->key != cacheKey)
 329             cacheHash = 0;
 330     } else
 331         cacheIterator = presentationAttributeCache().end();
 332
 333     RefPtr<StylePropertySet> style;
 334     if (cacheHash && cacheIterator->value) {
 335         style = cacheIterator->value->value;
 336         presentationAttributeCacheCleaner().didHitPresentationAttributeCache();
 337     } else {
 338         style = MutableStylePropertySet::create(isSVGElement() ? SVGAttributeMode : CSSQuirksMode);
 339         unsigned size = attributeCount();
 340         for (unsigned i = 0; i < size; ++i) {
 341             const Attribute* attribute = attributeItem(i);
 342             collectStyleForPresentationAttribute(attribute->name(), attribute->value(), static_cast<MutableStylePropertySet*>(style.get()));
 343         }
 344     }
 345
 346     // ShareableElementData doesn't store presentation attribute style, so make sure we have a UniqueElementData.
 347     UniqueElementData* elementData = ensureUniqueElementData();
 348
 349     elementData->m_presentationAttributeStyleIsDirty = false;
 350     elementData->m_presentationAttributeStyle = style->isEmpty() ? 0 : style;
 351
 352     if (!cacheHash || cacheIterator->value)
 353         return;
 354
 355     OwnPtr<PresentationAttributeCacheEntry> newEntry = adoptPtr(new PresentationAttributeCacheEntry);
 356     newEntry->key = cacheKey;
 357     newEntry->value = style.release();
 358
 359     static const int presentationAttributeCacheMaximumSize = 4096;
 360     if (presentationAttributeCache().size() > presentationAttributeCacheMaximumSize) {
 361         // Start building from scratch if the cache ever gets big.
 362         presentationAttributeCache().clear();
 363         presentationAttributeCache().set(cacheHash, newEntry.release());
 364     } else
 365         cacheIterator->value = newEntry.release();
 366 }
 367
 368 void StyledElement::addPropertyToPresentationAttributeStyle(MutableStylePropertySet* style, CSSPropertyID propertyID, int identifier)
 369 {
 370     style->setProperty(propertyID, cssValuePool().createIdentifierValue(identifier));
 371 }
 372
 373 void StyledElement::addPropertyToPresentationAttributeStyle(MutableStylePropertySet* style, CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitTypes unit)
 374 {
 375     style->setProperty(propertyID, cssValuePool().createValue(value, unit));
 376 }
 377
 378 void StyledElement::addPropertyToPresentationAttributeStyle(MutableStylePropertySet* style, CSSPropertyID propertyID, const String& value)
 379 {
 380     style->setProperty(propertyID, value, false, document()->elementSheet()->contents());
 381 }
 382
 383 }