Remove ENABLE_INPUT_MULTIPLE_FIELDS_UI.
[WebKit-https.git] / 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 }