Use AtomicString in RuleSet and RuleFeature
[WebKit-https.git] / Source / WebCore / style / StyleSharingResolver.cpp
1 /*
2  * Copyright (C) 2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "StyleSharingResolver.h"
28
29 #include "DocumentRuleSets.h"
30 #include "ElementRuleCollector.h"
31 #include "HTMLInputElement.h"
32 #include "HTMLNames.h"
33 #include "NodeRenderStyle.h"
34 #include "RenderStyle.h"
35 #include "SVGElement.h"
36 #include "ShadowRoot.h"
37 #include "StyleScope.h"
38 #include "StyleUpdate.h"
39 #include "StyledElement.h"
40 #include "VisitedLinkState.h"
41 #include "WebVTTElement.h"
42 #include "XMLNames.h"
43
44 namespace WebCore {
45 namespace Style {
46
47 static const unsigned cStyleSearchThreshold = 10;
48
49 struct SharingResolver::Context {
50     const Update& update;
51     const StyledElement& element;
52     bool elementAffectedByClassRules;
53     EInsideLink elementLinkState;
54 };
55
56 SharingResolver::SharingResolver(const Document& document, const DocumentRuleSets& ruleSets, const SelectorFilter& selectorFilter)
57     : m_document(document)
58     , m_ruleSets(ruleSets)
59     , m_selectorFilter(selectorFilter)
60 {
61 }
62
63 static inline bool parentElementPreventsSharing(const Element& parentElement)
64 {
65     return parentElement.hasFlagsSetDuringStylingOfChildren();
66 }
67
68 static inline bool elementHasDirectionAuto(const Element& element)
69 {
70     // FIXME: This line is surprisingly hot, we may wish to inline hasDirectionAuto into StyleResolver.
71     return is<HTMLElement>(element) && downcast<HTMLElement>(element).hasDirectionAuto();
72 }
73
74 std::unique_ptr<RenderStyle> SharingResolver::resolve(const Element& searchElement, const Update& update)
75 {
76     if (!is<StyledElement>(searchElement))
77         return nullptr;
78     auto& element = downcast<StyledElement>(searchElement);
79     if (!element.parentElement())
80         return nullptr;
81     auto& parentElement = *element.parentElement();
82     if (parentElement.shadowRoot())
83         return nullptr;
84     if (!update.elementStyle(parentElement))
85         return nullptr;
86     // If the element has inline style it is probably unique.
87     if (element.inlineStyle())
88         return nullptr;
89     if (element.isSVGElement() && downcast<SVGElement>(element).animatedSMILStyleProperties())
90         return nullptr;
91     // Ids stop style sharing if they show up in the stylesheets.
92     auto& id = element.idForStyleResolution();
93     if (!id.isNull() && m_ruleSets.features().idsInRules.contains(id))
94         return nullptr;
95     if (parentElementPreventsSharing(parentElement))
96         return nullptr;
97     if (&element == m_document.cssTarget())
98         return nullptr;
99     if (elementHasDirectionAuto(element))
100         return nullptr;
101     if (element.shadowRoot() && !element.shadowRoot()->styleScope().resolver().ruleSets().authorStyle().hostPseudoClassRules().isEmpty())
102         return nullptr;
103
104     Context context {
105         update,
106         element,
107         element.hasClass() && classNamesAffectedByRules(element.classNames()),
108         m_document.visitedLinkState().determineLinkState(element)
109     };
110
111     // Check previous siblings and their cousins.
112     unsigned count = 0;
113     StyledElement* shareElement = nullptr;
114     Node* cousinList = element.previousSibling();
115     while (cousinList) {
116         shareElement = findSibling(context, cousinList, count);
117         if (shareElement)
118             break;
119         if (count >= cStyleSearchThreshold)
120             break;
121         cousinList = locateCousinList(cousinList->parentElement());
122     }
123
124     // If we have exhausted all our budget or our cousins.
125     if (!shareElement)
126         return nullptr;
127
128     // Can't share if sibling rules apply. This is checked at the end as it should rarely fail.
129     if (styleSharingCandidateMatchesRuleSet(element, m_ruleSets.sibling()))
130         return nullptr;
131     // Can't share if attribute rules apply.
132     if (styleSharingCandidateMatchesRuleSet(element, m_ruleSets.uncommonAttribute()))
133         return nullptr;
134     // Tracking child index requires unique style for each node. This may get set by the sibling rule match above.
135     if (parentElementPreventsSharing(parentElement))
136         return nullptr;
137
138     m_elementsSharingStyle.add(&element, shareElement);
139
140     return RenderStyle::clonePtr(*update.elementStyle(*shareElement));
141 }
142
143 StyledElement* SharingResolver::findSibling(const Context& context, Node* node, unsigned& count) const
144 {
145     for (; node; node = node->previousSibling()) {
146         if (!is<StyledElement>(*node))
147             continue;
148         if (canShareStyleWithElement(context, downcast<StyledElement>(*node)))
149             break;
150         if (count++ >= cStyleSearchThreshold)
151             return nullptr;
152     }
153     return downcast<StyledElement>(node);
154 }
155
156 Node* SharingResolver::locateCousinList(const Element* parent) const
157 {
158     for (unsigned count = 0; count < cStyleSearchThreshold; ++count) {
159         auto* elementSharingParentStyle = m_elementsSharingStyle.get(parent);
160         if (!elementSharingParentStyle)
161             return nullptr;
162         if (!parentElementPreventsSharing(*elementSharingParentStyle)) {
163             if (auto* cousin = elementSharingParentStyle->lastChild())
164                 return cousin;
165         }
166         parent = elementSharingParentStyle;
167     }
168
169     return nullptr;
170 }
171
172 static bool canShareStyleWithControl(const HTMLFormControlElement& element, const HTMLFormControlElement& formElement)
173 {
174     if (!is<HTMLInputElement>(formElement) || !is<HTMLInputElement>(element))
175         return false;
176
177     auto& thisInputElement = downcast<HTMLInputElement>(formElement);
178     auto& otherInputElement = downcast<HTMLInputElement>(element);
179
180     if (thisInputElement.isAutoFilled() != otherInputElement.isAutoFilled())
181         return false;
182     if (thisInputElement.shouldAppearChecked() != otherInputElement.shouldAppearChecked())
183         return false;
184     if (thisInputElement.isRequired() != otherInputElement.isRequired())
185         return false;
186
187     if (formElement.isDisabledFormControl() != element.isDisabledFormControl())
188         return false;
189
190     if (formElement.isInRange() != element.isInRange())
191         return false;
192
193     if (formElement.isOutOfRange() != element.isOutOfRange())
194         return false;
195
196     return true;
197 }
198
199 bool SharingResolver::canShareStyleWithElement(const Context& context, const StyledElement& candidateElement) const
200 {
201     auto& element = context.element;
202     auto* style = context.update.elementStyle(candidateElement);
203     if (!style)
204         return false;
205     if (style->unique())
206         return false;
207     if (style->hasUniquePseudoStyle())
208         return false;
209     if (candidateElement.tagQName() != element.tagQName())
210         return false;
211     if (candidateElement.inlineStyle())
212         return false;
213     if (candidateElement.needsStyleRecalc())
214         return false;
215     if (candidateElement.isSVGElement() && downcast<SVGElement>(candidateElement).animatedSMILStyleProperties())
216         return false;
217     if (candidateElement.isLink() != element.isLink())
218         return false;
219     if (candidateElement.hovered() != element.hovered())
220         return false;
221     if (candidateElement.active() != element.active())
222         return false;
223     if (candidateElement.focused() != element.focused())
224         return false;
225     if (candidateElement.shadowPseudoId() != element.shadowPseudoId())
226         return false;
227     if (&candidateElement == m_document.cssTarget())
228         return false;
229     if (!sharingCandidateHasIdenticalStyleAffectingAttributes(context, candidateElement))
230         return false;
231     if (const_cast<StyledElement&>(candidateElement).additionalPresentationAttributeStyle() != const_cast<StyledElement&>(element).additionalPresentationAttributeStyle())
232         return false;
233     if (candidateElement.affectsNextSiblingElementStyle() || candidateElement.styleIsAffectedByPreviousSibling())
234         return false;
235     if (candidateElement.styleAffectedByFocusWithin() || element.styleAffectedByFocusWithin())
236         return false;
237
238     auto& candidateElementId = candidateElement.idForStyleResolution();
239     if (!candidateElementId.isNull() && m_ruleSets.features().idsInRules.contains(candidateElementId))
240         return false;
241
242     bool isControl = is<HTMLFormControlElement>(candidateElement);
243
244     if (isControl != is<HTMLFormControlElement>(element))
245         return false;
246
247     if (isControl && !canShareStyleWithControl(downcast<HTMLFormControlElement>(element), downcast<HTMLFormControlElement>(candidateElement)))
248         return false;
249
250     if (style->transitions() || style->animations())
251         return false;
252
253     // Turn off style sharing for elements that can gain layers for reasons outside of the style system.
254     // See comments in RenderObject::setStyle().
255     if (candidateElement.hasTagName(HTMLNames::iframeTag) || candidateElement.hasTagName(HTMLNames::frameTag))
256         return false;
257
258     if (candidateElement.hasTagName(HTMLNames::embedTag) || candidateElement.hasTagName(HTMLNames::objectTag) || candidateElement.hasTagName(HTMLNames::appletTag) || candidateElement.hasTagName(HTMLNames::canvasTag))
259         return false;
260
261     if (elementHasDirectionAuto(candidateElement))
262         return false;
263
264     if (candidateElement.isLink() && context.elementLinkState != style->insideLink())
265         return false;
266
267     if (candidateElement.elementData() != element.elementData()) {
268         if (candidateElement.attributeWithoutSynchronization(HTMLNames::readonlyAttr) != element.attributeWithoutSynchronization(HTMLNames::readonlyAttr))
269             return false;
270         if (candidateElement.isSVGElement()) {
271             if (candidateElement.getAttribute(HTMLNames::typeAttr) != element.getAttribute(HTMLNames::typeAttr))
272                 return false;
273         } else {
274             if (candidateElement.attributeWithoutSynchronization(HTMLNames::typeAttr) != element.attributeWithoutSynchronization(HTMLNames::typeAttr))
275                 return false;
276         }
277     }
278
279     if (candidateElement.matchesValidPseudoClass() != element.matchesValidPseudoClass())
280         return false;
281
282     if (element.matchesInvalidPseudoClass() != element.matchesValidPseudoClass())
283         return false;
284
285     if (candidateElement.matchesIndeterminatePseudoClass() != element.matchesIndeterminatePseudoClass())
286         return false;
287
288     if (candidateElement.matchesDefaultPseudoClass() != element.matchesDefaultPseudoClass())
289         return false;
290
291     if (candidateElement.shadowRoot() && !candidateElement.shadowRoot()->styleScope().resolver().ruleSets().authorStyle().hostPseudoClassRules().isEmpty())
292         return false;
293
294 #if ENABLE(FULLSCREEN_API)
295     if (&element == m_document.webkitCurrentFullScreenElement() || &element == m_document.webkitCurrentFullScreenElement())
296         return false;
297 #endif
298     return true;
299 }
300
301 bool SharingResolver::styleSharingCandidateMatchesRuleSet(const StyledElement& element, const RuleSet* ruleSet) const
302 {
303     if (!ruleSet)
304         return false;
305
306     ElementRuleCollector collector(const_cast<StyledElement&>(element), m_ruleSets, &m_selectorFilter);
307     return collector.hasAnyMatchingRules(ruleSet);
308 }
309
310 bool SharingResolver::sharingCandidateHasIdenticalStyleAffectingAttributes(const Context& context, const StyledElement& sharingCandidate) const
311 {
312     auto& element = context.element;
313     if (element.elementData() == sharingCandidate.elementData())
314         return true;
315     if (element.attributeWithoutSynchronization(XMLNames::langAttr) != sharingCandidate.attributeWithoutSynchronization(XMLNames::langAttr))
316         return false;
317     if (element.attributeWithoutSynchronization(HTMLNames::langAttr) != sharingCandidate.attributeWithoutSynchronization(HTMLNames::langAttr))
318         return false;
319
320     if (context.elementAffectedByClassRules) {
321         if (!sharingCandidate.hasClass())
322             return false;
323         // SVG elements require a (slow!) getAttribute comparision because "class" is an animatable attribute for SVG.
324         if (element.isSVGElement()) {
325             if (element.getAttribute(HTMLNames::classAttr) != sharingCandidate.getAttribute(HTMLNames::classAttr))
326                 return false;
327         } else {
328             if (element.classNames() != sharingCandidate.classNames())
329                 return false;
330         }
331     } else if (sharingCandidate.hasClass() && classNamesAffectedByRules(sharingCandidate.classNames()))
332         return false;
333
334     if (const_cast<StyledElement&>(element).presentationAttributeStyle() != const_cast<StyledElement&>(sharingCandidate).presentationAttributeStyle())
335         return false;
336
337     return true;
338 }
339
340 bool SharingResolver::classNamesAffectedByRules(const SpaceSplitString& classNames) const
341 {
342     for (unsigned i = 0; i < classNames.size(); ++i) {
343         if (m_ruleSets.features().classesInRules.contains(classNames[i]))
344             return true;
345     }
346     return false;
347 }
348
349
350 }
351 }