a1c0d4d61be102b6091cf115cdffbd8f2065fb6d
[WebKit-https.git] / Source / WebCore / style / StyleTreeResolver.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  *           (C) 2007 David Smith (catfish.man@gmail.com)
7  * Copyright (C) 2004-2010, 2012-2016 Apple Inc. All rights reserved.
8  *           (C) 2007 Eric Seidel (eric@webkit.org)
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  */
25
26 #include "config.h"
27 #include "StyleTreeResolver.h"
28
29 #include "AuthorStyleSheets.h"
30 #include "CSSFontSelector.h"
31 #include "ComposedTreeAncestorIterator.h"
32 #include "ComposedTreeIterator.h"
33 #include "ElementIterator.h"
34 #include "HTMLBodyElement.h"
35 #include "HTMLSlotElement.h"
36 #include "LoaderStrategy.h"
37 #include "MainFrame.h"
38 #include "NodeRenderStyle.h"
39 #include "PlatformStrategies.h"
40 #include "Settings.h"
41 #include "ShadowRoot.h"
42 #include "StyleResolver.h"
43 #include "Text.h"
44
45 #if PLATFORM(IOS)
46 #include "WKContentObservation.h"
47 #endif
48
49 namespace WebCore {
50
51 namespace Style {
52
53 static RenderStyle* placeholderStyle;
54
55 static void ensurePlaceholderStyle(Document& document)
56 {
57     if (placeholderStyle)
58         return;
59     placeholderStyle = RenderStyle::createPtr().release();
60     placeholderStyle->setDisplay(NONE);
61     placeholderStyle->setIsPlaceholderStyle();
62     placeholderStyle->fontCascade().update(&document.fontSelector());
63 }
64
65 TreeResolver::TreeResolver(Document& document)
66     : m_document(document)
67 {
68     ensurePlaceholderStyle(document);
69 }
70
71 TreeResolver::~TreeResolver()
72 {
73 }
74
75 TreeResolver::Scope::Scope(Document& document)
76     : styleResolver(document.ensureStyleResolver())
77     , sharingResolver(document, styleResolver.ruleSets(), selectorFilter)
78 {
79 }
80
81 TreeResolver::Scope::Scope(ShadowRoot& shadowRoot, Scope& enclosingScope)
82     : styleResolver(shadowRoot.styleResolver())
83     , sharingResolver(shadowRoot.documentScope(), styleResolver.ruleSets(), selectorFilter)
84     , shadowRoot(&shadowRoot)
85     , enclosingScope(&enclosingScope)
86 {
87 }
88
89 TreeResolver::Parent::Parent(Document& document, Change change)
90     : element(nullptr)
91     , style(*document.renderStyle())
92     , change(change)
93 {
94 }
95
96 TreeResolver::Parent::Parent(Element& element, const RenderStyle& style, Change change)
97     : element(&element)
98     , style(style)
99     , change(change)
100 {
101 }
102
103 void TreeResolver::pushScope(ShadowRoot& shadowRoot)
104 {
105     m_scopeStack.append(adoptRef(*new Scope(shadowRoot, scope())));
106     scope().styleResolver.setOverrideDocumentElementStyle(m_documentElementStyle.get());
107 }
108
109 void TreeResolver::pushEnclosingScope()
110 {
111     ASSERT(scope().enclosingScope);
112     m_scopeStack.append(*scope().enclosingScope);
113     scope().styleResolver.setOverrideDocumentElementStyle(m_documentElementStyle.get());
114 }
115
116 void TreeResolver::popScope()
117 {
118     scope().styleResolver.setOverrideDocumentElementStyle(nullptr);
119     return m_scopeStack.removeLast();
120 }
121
122 std::unique_ptr<RenderStyle> TreeResolver::styleForElement(Element& element, const RenderStyle& inheritedStyle)
123 {
124     if (!m_document.haveStylesheetsLoaded() && !element.renderer()) {
125         m_document.setHasNodesWithPlaceholderStyle();
126         return RenderStyle::clonePtr(*placeholderStyle);
127     }
128
129     if (element.hasCustomStyleResolveCallbacks()) {
130         RenderStyle* shadowHostStyle = scope().shadowRoot ? m_update->elementStyle(*scope().shadowRoot->host()) : nullptr;
131         if (auto customStyle = element.resolveCustomStyle(inheritedStyle, shadowHostStyle)) {
132             if (customStyle->relations)
133                 commitRelations(WTFMove(customStyle->relations), *m_update);
134
135             return WTFMove(customStyle->renderStyle);
136         }
137     }
138
139     if (auto style = scope().sharingResolver.resolve(element, *m_update))
140         return style;
141
142     auto elementStyle = scope().styleResolver.styleForElement(element, &inheritedStyle, MatchAllRules, nullptr, &scope().selectorFilter);
143
144     if (elementStyle.relations)
145         commitRelations(WTFMove(elementStyle.relations), *m_update);
146
147     return WTFMove(elementStyle.renderStyle);
148 }
149
150 static void resetStyleForNonRenderedDescendants(Element& current)
151 {
152     // FIXME: This is not correct with shadow trees. This should be done with ComposedTreeIterator.
153     bool elementNeedingStyleRecalcAffectsNextSiblingElementStyle = false;
154     for (auto& child : childrenOfType<Element>(current)) {
155         bool affectedByPreviousSibling = child.styleIsAffectedByPreviousSibling() && elementNeedingStyleRecalcAffectsNextSiblingElementStyle;
156         if (child.needsStyleRecalc() || elementNeedingStyleRecalcAffectsNextSiblingElementStyle)
157             elementNeedingStyleRecalcAffectsNextSiblingElementStyle = child.affectsNextSiblingElementStyle();
158
159         if (child.needsStyleRecalc() || affectedByPreviousSibling) {
160             child.resetComputedStyle();
161             child.clearNeedsStyleRecalc();
162         }
163
164         if (child.childNeedsStyleRecalc()) {
165             resetStyleForNonRenderedDescendants(child);
166             child.clearChildNeedsStyleRecalc();
167         }
168     }
169 }
170
171 static bool affectsRenderedSubtree(Element& element, const RenderStyle& newStyle)
172 {
173     if (element.renderer())
174         return true;
175     if (newStyle.display() != NONE)
176         return true;
177     if (element.rendererIsNeeded(newStyle))
178         return true;
179     if (element.shouldMoveToFlowThread(newStyle))
180         return true;
181     return false;
182 }
183
184 ElementUpdate TreeResolver::resolveElement(Element& element)
185 {
186     auto newStyle = styleForElement(element, parent().style);
187
188     auto* renderer = element.renderer();
189
190     if (!affectsRenderedSubtree(element, *newStyle))
191         return { };
192
193     ElementUpdate update;
194
195     bool needsNewRenderer = !renderer || element.styleChangeType() == ReconstructRenderTree || parent().change == Detach;
196
197     std::unique_ptr<RenderStyle> animatedStyle;
198     if (!needsNewRenderer && m_document.frame()->animation().updateAnimations(*renderer, *newStyle, animatedStyle))
199         update.isSynthetic = true;
200
201     update.style = animatedStyle ? WTFMove(animatedStyle) : WTFMove(newStyle);
202     update.change = needsNewRenderer ? Detach : determineChange(renderer->style(), *update.style);
203
204     if (element.styleChangeType() == SyntheticStyleChange)
205         update.isSynthetic = true;
206
207     if (&element == m_document.documentElement()) {
208         m_documentElementStyle = RenderStyle::clonePtr(*update.style);
209         scope().styleResolver.setOverrideDocumentElementStyle(m_documentElementStyle.get());
210
211         // If "rem" units are used anywhere in the document, and if the document element's font size changes, then force font updating
212         // all the way down the tree. This is simpler than having to maintain a cache of objects (and such font size changes should be rare anyway).
213         if (m_document.authorStyleSheets().usesRemUnits() && update.change != NoChange && renderer && renderer->style().fontSize() != update.style->fontSize()) {
214             // Cached RenderStyles may depend on the rem units.
215             scope().styleResolver.invalidateMatchedPropertiesCache();
216             update.change = Force;
217         }
218     }
219
220     // This is needed for resolving color:-webkit-text for subsequent elements.
221     // FIXME: We shouldn't mutate document when resolving style.
222     if (&element == m_document.body())
223         m_document.setTextColor(update.style->visitedDependentColor(CSSPropertyColor));
224
225     if (update.change != Detach && (parent().change == Force || element.styleChangeType() >= FullStyleChange))
226         update.change = Force;
227
228     return update;
229 }
230
231 #if PLATFORM(IOS)
232 static EVisibility elementImplicitVisibility(const Element* element)
233 {
234     RenderObject* renderer = element->renderer();
235     if (!renderer)
236         return VISIBLE;
237
238     auto& style = renderer->style();
239
240     Length width(style.width());
241     Length height(style.height());
242     if ((width.isFixed() && width.value() <= 0) || (height.isFixed() && height.value() <= 0))
243         return HIDDEN;
244
245     Length top(style.top());
246     Length left(style.left());
247     if (left.isFixed() && width.isFixed() && -left.value() >= width.value())
248         return HIDDEN;
249
250     if (top.isFixed() && height.isFixed() && -top.value() >= height.value())
251         return HIDDEN;
252     return VISIBLE;
253 }
254
255 class CheckForVisibilityChangeOnRecalcStyle {
256 public:
257     CheckForVisibilityChangeOnRecalcStyle(Element* element, const RenderStyle* currentStyle)
258         : m_element(element)
259         , m_previousDisplay(currentStyle ? currentStyle->display() : NONE)
260         , m_previousVisibility(currentStyle ? currentStyle->visibility() : HIDDEN)
261         , m_previousImplicitVisibility(WKObservingContentChanges() && WKObservedContentChange() != WKContentVisibilityChange ? elementImplicitVisibility(element) : VISIBLE)
262     {
263     }
264     ~CheckForVisibilityChangeOnRecalcStyle()
265     {
266         if (!WKObservingContentChanges())
267             return;
268         if (m_element->isInUserAgentShadowTree())
269             return;
270         auto* style = m_element->renderStyle();
271         if (!style)
272             return;
273         if ((m_previousDisplay == NONE && style->display() != NONE) || (m_previousVisibility == HIDDEN && style->visibility() != HIDDEN)
274             || (m_previousImplicitVisibility == HIDDEN && elementImplicitVisibility(m_element.get()) == VISIBLE))
275             WKSetObservedContentChange(WKContentVisibilityChange);
276     }
277 private:
278     RefPtr<Element> m_element;
279     EDisplay m_previousDisplay;
280     EVisibility m_previousVisibility;
281     EVisibility m_previousImplicitVisibility;
282 };
283 #endif // PLATFORM(IOS)
284
285 void TreeResolver::pushParent(Element& element, const RenderStyle& style, Change change)
286 {
287     scope().selectorFilter.pushParent(&element);
288
289     Parent parent(element, style, change);
290
291     if (auto* shadowRoot = element.shadowRoot()) {
292         pushScope(*shadowRoot);
293         parent.didPushScope = true;
294     }
295 #if ENABLE(SHADOW_DOM) || ENABLE(DETAILS_ELEMENT)
296     else if (is<HTMLSlotElement>(element) && downcast<HTMLSlotElement>(element).assignedNodes()) {
297         pushEnclosingScope();
298         parent.didPushScope = true;
299     }
300 #endif
301
302     m_parentStack.append(WTFMove(parent));
303 }
304
305 void TreeResolver::popParent()
306 {
307     auto& parentElement = *parent().element;
308
309     parentElement.clearNeedsStyleRecalc();
310     parentElement.clearChildNeedsStyleRecalc();
311
312     if (parent().didPushScope)
313         popScope();
314
315     scope().selectorFilter.popParent();
316
317     m_parentStack.removeLast();
318 }
319
320 void TreeResolver::popParentsToDepth(unsigned depth)
321 {
322     ASSERT(depth);
323     ASSERT(m_parentStack.size() >= depth);
324
325     while (m_parentStack.size() > depth)
326         popParent();
327 }
328
329 static bool shouldResolvePseudoElement(PseudoElement* pseudoElement)
330 {
331     if (!pseudoElement)
332         return false;
333     bool needsStyleRecalc = pseudoElement->needsStyleRecalc();
334     pseudoElement->clearNeedsStyleRecalc();
335     return needsStyleRecalc;
336 }
337
338 void TreeResolver::resolveComposedTree()
339 {
340     ASSERT(m_parentStack.size() == 1);
341     ASSERT(m_scopeStack.size() == 1);
342
343     auto descendants = composedTreeDescendants(m_document);
344     auto it = descendants.begin();
345     auto end = descendants.end();
346
347     // FIXME: SVG <use> element may cause tree mutations during style recalc.
348     it.dropAssertions();
349
350     while (it != end) {
351         popParentsToDepth(it.depth());
352
353         auto& node = *it;
354         auto& parent = this->parent();
355
356         ASSERT(node.containingShadowRoot() == scope().shadowRoot);
357         ASSERT(node.parentElement() == parent.element || is<ShadowRoot>(node.parentNode()) || node.parentElement()->shadowRoot());
358
359         if (is<Text>(node)) {
360             auto& text = downcast<Text>(node);
361             if (text.styleChangeType() == ReconstructRenderTree && parent.change != Detach)
362                 m_update->addText(text, parent.element);
363
364             text.clearNeedsStyleRecalc();
365             it.traverseNextSkippingChildren();
366             continue;
367         }
368
369         auto& element = downcast<Element>(node);
370
371         if (it.depth() > Settings::defaultMaximumRenderTreeDepth) {
372             resetStyleForNonRenderedDescendants(element);
373             element.clearChildNeedsStyleRecalc();
374             it.traverseNextSkippingChildren();
375             continue;
376         }
377
378         // FIXME: We should deal with this during style invalidation.
379         bool affectedByPreviousSibling = element.styleIsAffectedByPreviousSibling() && parent.elementNeedingStyleRecalcAffectsNextSiblingElementStyle;
380         if (element.needsStyleRecalc() || parent.elementNeedingStyleRecalcAffectsNextSiblingElementStyle)
381             parent.elementNeedingStyleRecalcAffectsNextSiblingElementStyle = element.affectsNextSiblingElementStyle();
382
383         bool shouldResolveForPseudoElement = shouldResolvePseudoElement(element.beforePseudoElement()) || shouldResolvePseudoElement(element.afterPseudoElement());
384
385         const RenderStyle* style;
386         Change change;
387
388         bool shouldResolve = parent.change >= Inherit || element.needsStyleRecalc() || shouldResolveForPseudoElement || affectedByPreviousSibling || element.hasDisplayContents();
389         if (shouldResolve) {
390 #if PLATFORM(IOS)
391             CheckForVisibilityChangeOnRecalcStyle checkForVisibilityChange(&element, element.renderStyle());
392 #endif
393             element.resetComputedStyle();
394
395             if (element.hasCustomStyleResolveCallbacks()) {
396                 if (!element.willRecalcStyle(parent.change)) {
397                     it.traverseNextSkippingChildren();
398                     continue;
399                 }
400             }
401
402             auto elementUpdate = resolveElement(element);
403
404             if (element.hasCustomStyleResolveCallbacks())
405                 element.didRecalcStyle(elementUpdate.change);
406
407             style = elementUpdate.style.get();
408             change = elementUpdate.change;
409
410             if (affectedByPreviousSibling && change != Detach)
411                 change = Force;
412
413             if (elementUpdate.style)
414                 m_update->addElement(element, parent.element, WTFMove(elementUpdate));
415
416             element.clearNeedsStyleRecalc();
417         } else {
418             style = element.renderStyle();
419             change = NoChange;
420         }
421
422         if (!style) {
423             resetStyleForNonRenderedDescendants(element);
424             element.clearChildNeedsStyleRecalc();
425         }
426
427         bool shouldIterateChildren = style && (element.childNeedsStyleRecalc() || change != NoChange);
428         if (!shouldIterateChildren) {
429             it.traverseNextSkippingChildren();
430             continue;
431         }
432
433         pushParent(element, *style, change);
434
435         it.traverseNext();
436     }
437
438     popParentsToDepth(1);
439 }
440
441 std::unique_ptr<Update> TreeResolver::resolve(Change change)
442 {
443     auto& renderView = *m_document.renderView();
444
445     Element* documentElement = m_document.documentElement();
446     if (!documentElement)
447         return nullptr;
448     if (change != Force && !documentElement->childNeedsStyleRecalc() && !documentElement->needsStyleRecalc())
449         return nullptr;
450
451     m_update = std::make_unique<Update>(m_document);
452     m_scopeStack.append(adoptRef(*new Scope(m_document)));
453     m_parentStack.append(Parent(m_document, change));
454
455     // Pseudo element removal and similar may only work with these flags still set. Reset them after the style recalc.
456     renderView.setUsesFirstLineRules(renderView.usesFirstLineRules() || scope().styleResolver.usesFirstLineRules());
457     renderView.setUsesFirstLetterRules(renderView.usesFirstLetterRules() || scope().styleResolver.usesFirstLetterRules());
458
459     resolveComposedTree();
460
461     renderView.setUsesFirstLineRules(scope().styleResolver.usesFirstLineRules());
462     renderView.setUsesFirstLetterRules(scope().styleResolver.usesFirstLetterRules());
463
464     ASSERT(m_scopeStack.size() == 1);
465     ASSERT(m_parentStack.size() == 1);
466     m_parentStack.clear();
467     popScope();
468
469     if (m_update->roots().isEmpty())
470         return { };
471
472     return WTFMove(m_update);
473 }
474
475 static Vector<std::function<void ()>>& postResolutionCallbackQueue()
476 {
477     static NeverDestroyed<Vector<std::function<void ()>>> vector;
478     return vector;
479 }
480
481 void queuePostResolutionCallback(std::function<void ()> callback)
482 {
483     postResolutionCallbackQueue().append(callback);
484 }
485
486 static void suspendMemoryCacheClientCalls(Document& document)
487 {
488     Page* page = document.page();
489     if (!page || !page->areMemoryCacheClientCallsEnabled())
490         return;
491
492     page->setMemoryCacheClientCallsEnabled(false);
493
494     RefPtr<MainFrame> protectedMainFrame = &page->mainFrame();
495     postResolutionCallbackQueue().append([protectedMainFrame]{
496         if (Page* page = protectedMainFrame->page())
497             page->setMemoryCacheClientCallsEnabled(true);
498     });
499 }
500
501 static unsigned resolutionNestingDepth;
502
503 PostResolutionCallbackDisabler::PostResolutionCallbackDisabler(Document& document)
504 {
505     ++resolutionNestingDepth;
506
507     if (resolutionNestingDepth == 1)
508         platformStrategies()->loaderStrategy()->suspendPendingRequests();
509
510     // FIXME: It's strange to build this into the disabler.
511     suspendMemoryCacheClientCalls(document);
512 }
513
514 PostResolutionCallbackDisabler::~PostResolutionCallbackDisabler()
515 {
516     if (resolutionNestingDepth == 1) {
517         // Get size each time through the loop because a callback can add more callbacks to the end of the queue.
518         auto& queue = postResolutionCallbackQueue();
519         for (size_t i = 0; i < queue.size(); ++i)
520             queue[i]();
521         queue.clear();
522
523         platformStrategies()->loaderStrategy()->resumePendingRequests();
524     }
525
526     --resolutionNestingDepth;
527 }
528
529 bool postResolutionCallbacksAreSuspended()
530 {
531     return resolutionNestingDepth;
532 }
533
534 bool isPlaceholderStyle(const RenderStyle& style)
535 {
536     return &style == placeholderStyle;
537 }
538
539 }
540 }