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::updateStyleAttribute() const
 130 {
 131     ASSERT(attributeData());
 132     ASSERT(attributeData()->m_styleAttributeIsDirty);
 133     attributeData()->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 StylePropertySet* StyledElement::ensureMutableInlineStyle()
 150 {
 151     RefPtr<StylePropertySet>& inlineStyle = mutableAttributeData()->m_inlineStyle;
 152     if (!inlineStyle)
 153         inlineStyle = StylePropertySet::create(strictToCSSParserMode(isHTMLElement() && !document()->inQuirksMode()));
 154     else if (!inlineStyle->isMutable())
 155         inlineStyle = inlineStyle->copy();
 156     return inlineStyle.get();
 157 }
 158
 159 void StyledElement::attributeChanged(const QualifiedName& name, const AtomicString& newValue)
 160 {
 161     if (name == styleAttr)
 162         styleAttributeChanged(newValue);
 163     else if (isPresentationAttribute(name)) {
 164         attributeData()->m_presentationAttributeStyleIsDirty = true;
 165         setNeedsStyleRecalc(InlineStyleChange);
 166     }
 167
 168     Element::attributeChanged(name, newValue);
 169 }
 170
 171 PropertySetCSSStyleDeclaration* StyledElement::inlineStyleCSSOMWrapper()
 172 {
 173     if (!inlineStyle() || !inlineStyle()->hasCSSOMWrapper())
 174         return 0;
 175     PropertySetCSSStyleDeclaration* cssomWrapper = mutableAttributeData()->m_inlineStyle->cssStyleDeclaration();
 176     ASSERT(cssomWrapper && cssomWrapper->parentElement() == this);
 177     return cssomWrapper;
 178 }
 179
 180 inline void StyledElement::setInlineStyleFromString(const AtomicString& newStyleString)
 181 {
 182     RefPtr<StylePropertySet>& inlineStyle = attributeData()->m_inlineStyle;
 183
 184     // Avoid redundant work if we're using shared attribute data with already parsed inline style.
 185     if (inlineStyle && !attributeData()->isMutable())
 186         return;
 187
 188     // We reconstruct the property set instead of mutating if there is no CSSOM wrapper.
 189     // This makes wrapperless property sets immutable and so cacheable.
 190     if (inlineStyle && !inlineStyle->isMutable())
 191         inlineStyle.clear();
 192
 193     if (!inlineStyle)
 194         inlineStyle = CSSParser::parseInlineStyleDeclaration(newStyleString, this);
 195     else
 196         inlineStyle->parseDeclaration(newStyleString, document()->elementSheet()->contents());
 197 }
 198
 199 void StyledElement::styleAttributeChanged(const AtomicString& newStyleString)
 200 {
 201     WTF::OrdinalNumber startLineNumber = WTF::OrdinalNumber::beforeFirst();
 202     if (document() && document()->scriptableDocumentParser() && !document()->isInDocumentWrite())
 203         startLineNumber = document()->scriptableDocumentParser()->lineNumber();
 204
 205     if (newStyleString.isNull()) {
 206         if (PropertySetCSSStyleDeclaration* cssomWrapper = inlineStyleCSSOMWrapper())
 207             cssomWrapper->clearParentElement();
 208         mutableAttributeData()->m_inlineStyle.clear();
 209     } else if (document()->contentSecurityPolicy()->allowInlineStyle(document()->url(), startLineNumber))
 210         setInlineStyleFromString(newStyleString);
 211
 212     attributeData()->m_styleAttributeIsDirty = false;
 213
 214     setNeedsStyleRecalc(InlineStyleChange);
 215     InspectorInstrumentation::didInvalidateStyleAttr(document(), this);
 216 }
 217
 218 void StyledElement::inlineStyleChanged()
 219 {
 220     setNeedsStyleRecalc(InlineStyleChange);
 221     ASSERT(attributeData());
 222     attributeData()->m_styleAttributeIsDirty = true;
 223     InspectorInstrumentation::didInvalidateStyleAttr(document(), this);
 224 }
 225
 226 bool StyledElement::setInlineStyleProperty(CSSPropertyID propertyID, int identifier, bool important)
 227 {
 228     ensureMutableInlineStyle()->setProperty(propertyID, cssValuePool().createIdentifierValue(identifier), important);
 229     inlineStyleChanged();
 230     return true;
 231 }
 232
 233 bool StyledElement::setInlineStyleProperty(CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitTypes unit, bool important)
 234 {
 235     ensureMutableInlineStyle()->setProperty(propertyID, cssValuePool().createValue(value, unit), important);
 236     inlineStyleChanged();
 237     return true;
 238 }
 239
 240 bool StyledElement::setInlineStyleProperty(CSSPropertyID propertyID, const String& value, bool important)
 241 {
 242     bool changes = ensureMutableInlineStyle()->setProperty(propertyID, value, important, document()->elementSheet()->contents());
 243     if (changes)
 244         inlineStyleChanged();
 245     return changes;
 246 }
 247
 248 bool StyledElement::removeInlineStyleProperty(CSSPropertyID propertyID)
 249 {
 250     if (!inlineStyle())
 251         return false;
 252     bool changes = ensureMutableInlineStyle()->removeProperty(propertyID);
 253     if (changes)
 254         inlineStyleChanged();
 255     return changes;
 256 }
 257
 258 void StyledElement::removeAllInlineStyleProperties()
 259 {
 260     if (!inlineStyle() || inlineStyle()->isEmpty())
 261         return;
 262     ensureMutableInlineStyle()->clear();
 263     inlineStyleChanged();
 264 }
 265
 266 void StyledElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
 267 {
 268     if (const StylePropertySet* inlineStyle = attributeData() ? attributeData()->inlineStyle() : 0)
 269         inlineStyle->addSubresourceStyleURLs(urls, document()->elementSheet()->contents());
 270 }
 271
 272 static inline bool attributeNameSort(const pair<AtomicStringImpl*, AtomicString>& p1, const pair<AtomicStringImpl*, AtomicString>& p2)
 273 {
 274     // Sort based on the attribute name pointers. It doesn't matter what the order is as long as it is always the same.
 275     return p1.first < p2.first;
 276 }
 277
 278 void StyledElement::makePresentationAttributeCacheKey(PresentationAttributeCacheKey& result) const
 279 {
 280     // FIXME: Enable for SVG.
 281     if (namespaceURI() != xhtmlNamespaceURI)
 282         return;
 283     // Interpretation of the size attributes on <input> depends on the type attribute.
 284     if (hasTagName(inputTag))
 285         return;
 286     unsigned size = attributeCount();
 287     for (unsigned i = 0; i < size; ++i) {
 288         const Attribute* attribute = attributeItem(i);
 289         if (!isPresentationAttribute(attribute->name()))
 290             continue;
 291         if (!attribute->namespaceURI().isNull())
 292             return;
 293         // FIXME: Background URL may depend on the base URL and can't be shared. Disallow caching.
 294         if (attribute->name() == backgroundAttr)
 295             return;
 296         result.attributesAndValues.append(make_pair(attribute->localName().impl(), attribute->value()));
 297     }
 298     if (result.attributesAndValues.isEmpty())
 299         return;
 300     // Attribute order doesn't matter. Sort for easy equality comparison.
 301     std::sort(result.attributesAndValues.begin(), result.attributesAndValues.end(), attributeNameSort);
 302     // The cache key is non-null when the tagName is set.
 303     result.tagName = localName().impl();
 304 }
 305
 306 static unsigned computePresentationAttributeCacheHash(const PresentationAttributeCacheKey& key)
 307 {
 308     if (!key.tagName)
 309         return 0;
 310     ASSERT(key.attributesAndValues.size());
 311     unsigned attributeHash = StringHasher::hashMemory(key.attributesAndValues.data(), key.attributesAndValues.size() * sizeof(key.attributesAndValues[0]));
 312     return WTF::pairIntHash(key.tagName->existingHash(), attributeHash);
 313 }
 314
 315 void StyledElement::rebuildPresentationAttributeStyle()
 316 {
 317     PresentationAttributeCacheKey cacheKey;
 318     makePresentationAttributeCacheKey(cacheKey);
 319
 320     unsigned cacheHash = computePresentationAttributeCacheHash(cacheKey);
 321
 322     PresentationAttributeCache::iterator cacheIterator;
 323     if (cacheHash) {
 324         cacheIterator = presentationAttributeCache().add(cacheHash, nullptr).iterator;
 325         if (cacheIterator->value && cacheIterator->value->key != cacheKey)
 326             cacheHash = 0;
 327     } else
 328         cacheIterator = presentationAttributeCache().end();
 329
 330     RefPtr<StylePropertySet> style;
 331     if (cacheHash && cacheIterator->value) {
 332         style = cacheIterator->value->value;
 333         presentationAttributeCacheCleaner().didHitPresentationAttributeCache();
 334     } else {
 335         style = StylePropertySet::create(isSVGElement() ? SVGAttributeMode : CSSQuirksMode);
 336         unsigned size = attributeCount();
 337         for (unsigned i = 0; i < size; ++i) {
 338             const Attribute* attribute = attributeItem(i);
 339             collectStyleForPresentationAttribute(*attribute, style.get());
 340         }
 341     }
 342
 343     // ImmutableElementAttributeData doesn't store presentation attribute style, so make sure we have a MutableElementAttributeData.
 344     ElementAttributeData* attributeData = mutableAttributeData();
 345
 346     attributeData->m_presentationAttributeStyleIsDirty = false;
 347     attributeData->setPresentationAttributeStyle(style->isEmpty() ? 0 : style);
 348
 349     if (!cacheHash || cacheIterator->value)
 350         return;
 351
 352     OwnPtr<PresentationAttributeCacheEntry> newEntry = adoptPtr(new PresentationAttributeCacheEntry);
 353     newEntry->key = cacheKey;
 354     newEntry->value = style.release();
 355
 356     static const int presentationAttributeCacheMaximumSize = 4096;
 357     if (presentationAttributeCache().size() > presentationAttributeCacheMaximumSize) {
 358         // Start building from scratch if the cache ever gets big.
 359         presentationAttributeCache().clear();
 360         presentationAttributeCache().set(cacheHash, newEntry.release());
 361     } else
 362         cacheIterator->value = newEntry.release();
 363 }
 364
 365 void StyledElement::addPropertyToPresentationAttributeStyle(StylePropertySet* style, CSSPropertyID propertyID, int identifier)
 366 {
 367     style->setProperty(propertyID, cssValuePool().createIdentifierValue(identifier));
 368 }
 369
 370 void StyledElement::addPropertyToPresentationAttributeStyle(StylePropertySet* style, CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitTypes unit)
 371 {
 372     style->setProperty(propertyID, cssValuePool().createValue(value, unit));
 373 }
 374
 375 void StyledElement::addPropertyToPresentationAttributeStyle(StylePropertySet* style, CSSPropertyID propertyID, const String& value)
 376 {
 377     style->setProperty(propertyID, value, false, document()->elementSheet()->contents());
 378 }
 379
 380 }