Reverse ownership relation of StyleCachedImage and CSSImageValue
[WebKit-https.git] / Source / WebCore / css / StyleResolver.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #pragma once
23
24 #include "CSSToLengthConversionData.h"
25 #include "CSSToStyleMap.h"
26 #include "DocumentRuleSets.h"
27 #include "InspectorCSSOMWrappers.h"
28 #include "MediaQueryEvaluator.h"
29 #include "RenderStyle.h"
30 #include "RuleFeature.h"
31 #include "RuleSet.h"
32 #include "SelectorChecker.h"
33 #include "StylePendingResources.h"
34 #include <bitset>
35 #include <memory>
36 #include <wtf/HashMap.h>
37 #include <wtf/HashSet.h>
38 #include <wtf/RefPtr.h>
39 #include <wtf/Vector.h>
40 #include <wtf/text/AtomicStringHash.h>
41 #include <wtf/text/StringHash.h>
42
43 namespace WebCore {
44
45 class CSSCursorImageValue;
46 class CSSFontFace;
47 class CSSFontFaceRule;
48 class CSSFontValue;
49 class CSSImageGeneratorValue;
50 class CSSImageSetValue;
51 class CSSImageValue;
52 class CSSPageRule;
53 class CSSPrimitiveValue;
54 class CSSProperty;
55 class CSSSelector;
56 class CSSStyleSheet;
57 class CSSValue;
58 class CSSVariableDependentValue;
59 class ContainerNode;
60 class Document;
61 class Element;
62 class Frame;
63 class FrameView;
64 class URL;
65 class KeyframeList;
66 class KeyframeValue;
67 class MediaQueryEvaluator;
68 class Node;
69 class RenderRegion;
70 class RenderScrollbar;
71 class RuleData;
72 class RuleSet;
73 class SelectorFilter;
74 class Settings;
75 class StyleCachedImage;
76 class StyleGeneratedImage;
77 class StyleImage;
78 class StyleKeyframe;
79 class StylePendingImage;
80 class StyleProperties;
81 class StyleRule;
82 class StyleRuleKeyframes;
83 class StyleRulePage;
84 class StyleRuleRegion;
85 class StyleSheet;
86 class StyleSheetList;
87 class StyledElement;
88 class SVGSVGElement;
89 class ViewportStyleResolver;
90 class WebKitCSSFilterValue;
91 struct ResourceLoaderOptions;
92
93 // MatchOnlyUserAgentRules is used in media queries, where relative units
94 // are interpreted according to the document root element style, and styled only
95 // from the User Agent Stylesheet rules.
96
97 enum RuleMatchingBehavior {
98     MatchAllRules,
99     MatchAllRulesExcludingSMIL,
100     MatchOnlyUserAgentRules,
101 };
102
103 enum CascadeLevel {
104     UserAgentLevel,
105     AuthorLevel,
106     UserLevel
107 };
108
109 class PseudoStyleRequest {
110 public:
111     PseudoStyleRequest(PseudoId pseudoId, RenderScrollbar* scrollbar = nullptr, ScrollbarPart scrollbarPart = NoPart)
112         : pseudoId(pseudoId)
113         , scrollbarPart(scrollbarPart)
114         , scrollbar(scrollbar)
115     {
116     }
117
118     PseudoId pseudoId;
119     ScrollbarPart scrollbarPart;
120     RenderScrollbar* scrollbar;
121 };
122
123 struct ElementStyle {
124     ElementStyle(std::unique_ptr<RenderStyle> renderStyle, std::unique_ptr<Style::Relations> relations = { })
125         : renderStyle(WTFMove(renderStyle))
126         , relations(WTFMove(relations))
127     { }
128
129     std::unique_ptr<RenderStyle> renderStyle;
130     std::unique_ptr<Style::Relations> relations;
131 };
132
133 // This class selects a RenderStyle for a given element based on a collection of stylesheets.
134 class StyleResolver {
135     WTF_MAKE_NONCOPYABLE(StyleResolver); WTF_MAKE_FAST_ALLOCATED;
136 public:
137     StyleResolver(Document&);
138     ~StyleResolver();
139
140     ElementStyle styleForElement(const Element&, const RenderStyle* parentStyle, RuleMatchingBehavior = MatchAllRules, const RenderRegion* regionForStyling = nullptr, const SelectorFilter* = nullptr);
141
142     void keyframeStylesForAnimation(const Element&, const RenderStyle*, KeyframeList&);
143
144     std::unique_ptr<RenderStyle> pseudoStyleForElement(const Element&, const PseudoStyleRequest&, const RenderStyle& parentStyle);
145
146     std::unique_ptr<RenderStyle> styleForPage(int pageIndex);
147     std::unique_ptr<RenderStyle> defaultStyleForElement();
148
149     RenderStyle* style() const { return m_state.style(); }
150     const RenderStyle* parentStyle() const { return m_state.parentStyle(); }
151     const RenderStyle* rootElementStyle() const { return m_state.rootElementStyle(); }
152     const Element* element() { return m_state.element(); }
153     Document& document() { return m_document; }
154     const Document& document() const { return m_document; }
155     Settings* documentSettings() { return m_document.settings(); }
156
157     void appendAuthorStyleSheets(const Vector<RefPtr<CSSStyleSheet>>&);
158
159     DocumentRuleSets& ruleSets() { return m_ruleSets; }
160     const DocumentRuleSets& ruleSets() const { return m_ruleSets; }
161
162     const MediaQueryEvaluator& mediaQueryEvaluator() const { return m_mediaQueryEvaluator; }
163
164     void setOverrideDocumentElementStyle(RenderStyle* style) { m_overrideDocumentElementStyle = style; }
165
166 private:
167     std::unique_ptr<RenderStyle> styleForKeyframe(const RenderStyle*, const StyleKeyframe*, KeyframeValue&);
168
169 public:
170     // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
171     enum CSSRuleFilter {
172         UAAndUserCSSRules   = 1 << 1,
173         AuthorCSSRules      = 1 << 2,
174         EmptyCSSRules       = 1 << 3,
175         CrossOriginCSSRules = 1 << 4,
176         AllButEmptyCSSRules = UAAndUserCSSRules | AuthorCSSRules | CrossOriginCSSRules,
177         AllCSSRules         = AllButEmptyCSSRules | EmptyCSSRules,
178     };
179     Vector<RefPtr<StyleRule>> styleRulesForElement(const Element*, unsigned rulesToInclude = AllButEmptyCSSRules);
180     Vector<RefPtr<StyleRule>> pseudoStyleRulesForElement(const Element*, PseudoId, unsigned rulesToInclude = AllButEmptyCSSRules);
181
182 public:
183     struct MatchResult;
184
185     void applyPropertyToStyle(CSSPropertyID, CSSValue*, std::unique_ptr<RenderStyle>);
186     void applyPropertyToCurrentStyle(CSSPropertyID, CSSValue*);
187
188     void updateFont();
189     void initializeFontStyle(Settings*);
190
191     void setFontSize(FontCascadeDescription&, float size);
192
193 public:
194     bool useSVGZoomRules();
195     bool useSVGZoomRulesForLength();
196
197     static bool colorFromPrimitiveValueIsDerivedFromElement(const CSSPrimitiveValue&);
198     Color colorFromPrimitiveValue(const CSSPrimitiveValue&, bool forVisitedLink = false) const;
199
200     bool hasSelectorForId(const AtomicString&) const;
201     bool hasSelectorForClass(const AtomicString&) const;
202     bool hasSelectorForAttribute(const Element&, const AtomicString&) const;
203
204 #if ENABLE(CSS_DEVICE_ADAPTATION)
205     ViewportStyleResolver* viewportStyleResolver() { return m_viewportStyleResolver.get(); }
206 #endif
207
208     void addViewportDependentMediaQueryResult(const MediaQueryExpression&, bool result);
209     bool hasViewportDependentMediaQueries() const { return !m_viewportDependentMediaQueryResults.isEmpty(); }
210     bool hasMediaQueriesAffectedByViewportChange() const;
211
212     void addKeyframeStyle(Ref<StyleRuleKeyframes>&&);
213
214     bool checkRegionStyle(const Element* regionElement);
215
216     bool usesFirstLineRules() const { return m_ruleSets.features().usesFirstLineRules; }
217     bool usesFirstLetterRules() const { return m_ruleSets.features().usesFirstLetterRules; }
218     
219     void invalidateMatchedPropertiesCache();
220
221     void clearCachedPropertiesAffectedByViewportUnits();
222
223     bool createFilterOperations(const CSSValue& inValue, FilterOperations& outOperations);
224     void loadPendingSVGDocuments();
225
226     void loadPendingResources();
227
228     struct RuleRange {
229         RuleRange(int& firstRuleIndex, int& lastRuleIndex): firstRuleIndex(firstRuleIndex), lastRuleIndex(lastRuleIndex) { }
230         int& firstRuleIndex;
231         int& lastRuleIndex;
232     };
233
234     struct MatchRanges {
235         MatchRanges() : firstUARule(-1), lastUARule(-1), firstAuthorRule(-1), lastAuthorRule(-1), firstUserRule(-1), lastUserRule(-1) { }
236         int firstUARule;
237         int lastUARule;
238         int firstAuthorRule;
239         int lastAuthorRule;
240         int firstUserRule;
241         int lastUserRule;
242         RuleRange UARuleRange() { return RuleRange(firstUARule, lastUARule); }
243         RuleRange authorRuleRange() { return RuleRange(firstAuthorRule, lastAuthorRule); }
244         RuleRange userRuleRange() { return RuleRange(firstUserRule, lastUserRule); }
245     };
246
247     struct MatchedProperties {
248         MatchedProperties();
249         ~MatchedProperties();
250         
251         RefPtr<StyleProperties> properties;
252         union {
253             struct {
254                 unsigned linkMatchType : 2;
255                 unsigned whitelistType : 2;
256                 unsigned treeContextOrdinal : 28;
257             };
258             // Used to make sure all memory is zero-initialized since we compute the hash over the bytes of this object.
259             void* possiblyPaddedMember;
260         };
261     };
262
263     struct MatchResult {
264         MatchResult() : isCacheable(true) { }
265         Vector<StyleRule*, 64> matchedRules;
266         MatchRanges ranges;
267         bool isCacheable;
268
269         const Vector<MatchedProperties, 64>& matchedProperties() const { return m_matchedProperties; }
270
271         void addMatchedProperties(const StyleProperties&, StyleRule* = nullptr, unsigned linkMatchType = SelectorChecker::MatchAll, PropertyWhitelistType = PropertyWhitelistNone, unsigned treeContextOrdinal = 0);
272     private:
273         Vector<MatchedProperties, 64> m_matchedProperties;
274     };
275     
276     class CascadedProperties {
277         WTF_MAKE_FAST_ALLOCATED;
278     public:
279         CascadedProperties(TextDirection, WritingMode);
280
281         struct Property {
282             void apply(StyleResolver&, const MatchResult*);
283
284             CSSPropertyID id;
285             CascadeLevel level;
286             CSSValue* cssValue[3];
287         };
288
289         bool hasProperty(CSSPropertyID) const;
290         Property& property(CSSPropertyID);
291
292         void addNormalMatches(const MatchResult&, int startIndex, int endIndex, bool inheritedOnly = false);
293         void addImportantMatches(const MatchResult&, int startIndex, int endIndex, bool inheritedOnly = false);
294
295         void set(CSSPropertyID, CSSValue&, unsigned linkMatchType, CascadeLevel);
296         void setDeferred(CSSPropertyID, CSSValue&, unsigned linkMatchType, CascadeLevel);
297
298         void applyDeferredProperties(StyleResolver&, const MatchResult*);
299
300         HashMap<AtomicString, Property>& customProperties() { return m_customProperties; }
301         bool hasCustomProperty(const String&) const;
302         Property customProperty(const String&) const;
303         
304     private:
305         void addMatch(const MatchResult&, unsigned index, bool isImportant, bool inheritedOnly);
306         void addStyleProperties(const StyleProperties&, bool isImportant, bool inheritedOnly, PropertyWhitelistType, unsigned linkMatchType, CascadeLevel);
307         static void setPropertyInternal(Property&, CSSPropertyID, CSSValue&, unsigned linkMatchType, CascadeLevel);
308
309         Property m_properties[numCSSProperties + 2];
310         std::bitset<numCSSProperties + 2> m_propertyIsPresent;
311
312         Vector<Property, 8> m_deferredProperties;
313         HashMap<AtomicString, Property> m_customProperties;
314
315         TextDirection m_direction;
316         WritingMode m_writingMode;
317     };
318
319 private:
320     // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
321     void checkForGenericFamilyChange(RenderStyle*, const RenderStyle* parentStyle);
322     void checkForZoomChange(RenderStyle*, const RenderStyle* parentStyle);
323 #if ENABLE(IOS_TEXT_AUTOSIZING)
324     void checkForTextSizeAdjust(RenderStyle*);
325 #endif
326
327     void adjustRenderStyle(RenderStyle& styleToAdjust, const RenderStyle& parentStyle, const Element*);
328 #if ENABLE(CSS_GRID_LAYOUT)
329     std::unique_ptr<GridPosition> adjustNamedGridItemPosition(const NamedGridAreaMap&, const NamedGridLinesMap&, const GridPosition&, GridPositionSide) const;
330 #endif
331     
332     void adjustStyleForInterCharacterRuby();
333     
334     bool fastRejectSelector(const RuleData&) const;
335
336     enum ShouldUseMatchedPropertiesCache { DoNotUseMatchedPropertiesCache = 0, UseMatchedPropertiesCache };
337     void applyMatchedProperties(const MatchResult&, const Element&, ShouldUseMatchedPropertiesCache = UseMatchedPropertiesCache);
338
339     void applyCascadedProperties(CascadedProperties&, int firstProperty, int lastProperty, const MatchResult*);
340     void cascadeMatches(CascadedProperties&, const MatchResult&, bool important, int startIndex, int endIndex, bool inheritedOnly);
341
342     static bool isValidRegionStyleProperty(CSSPropertyID);
343 #if ENABLE(VIDEO_TRACK)
344     static bool isValidCueStyleProperty(CSSPropertyID);
345 #endif
346     void matchPageRules(MatchResult&, RuleSet*, bool isLeftPage, bool isFirstPage, const String& pageName);
347     void matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>&, bool isLeftPage, bool isFirstPage, const String& pageName);
348
349     bool isLeftPage(int pageIndex) const;
350     bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
351     bool isFirstPage(int pageIndex) const;
352     String pageName(int pageIndex) const;
353
354     DocumentRuleSets m_ruleSets;
355
356     typedef HashMap<AtomicStringImpl*, RefPtr<StyleRuleKeyframes>> KeyframesRuleMap;
357     KeyframesRuleMap m_keyframesRuleMap;
358
359 public:
360     typedef HashMap<CSSPropertyID, RefPtr<CSSValue>> PendingImagePropertyMap;
361
362     class State {
363     public:
364         State() { }
365         State(const Element&, const RenderStyle* parentStyle, const RenderStyle* documentElementStyle = nullptr, const RenderRegion* regionForStyling = nullptr, const SelectorFilter* = nullptr);
366
367     public:
368         void clear();
369
370         Document& document() const { return m_element->document(); }
371         const Element* element() const { return m_element; }
372
373         void setStyle(std::unique_ptr<RenderStyle>);
374         RenderStyle* style() const { return m_style.get(); }
375         std::unique_ptr<RenderStyle> takeStyle() { return WTFMove(m_style); }
376
377         void setParentStyle(std::unique_ptr<RenderStyle>);
378         const RenderStyle* parentStyle() const { return m_parentStyle; }
379         const RenderStyle* rootElementStyle() const { return m_rootElementStyle; }
380
381         const RenderRegion* regionForStyling() const { return m_regionForStyling; }
382         EInsideLink elementLinkState() const { return m_elementLinkState; }
383
384         void setApplyPropertyToRegularStyle(bool isApply) { m_applyPropertyToRegularStyle = isApply; }
385         void setApplyPropertyToVisitedLinkStyle(bool isApply) { m_applyPropertyToVisitedLinkStyle = isApply; }
386         bool applyPropertyToRegularStyle() const { return m_applyPropertyToRegularStyle; }
387         bool applyPropertyToVisitedLinkStyle() const { return m_applyPropertyToVisitedLinkStyle; }
388
389         void setFontDirty(bool isDirty) { m_fontDirty = isDirty; }
390         bool fontDirty() const { return m_fontDirty; }
391         void setFontSizeHasViewportUnits(bool hasViewportUnits) { m_fontSizeHasViewportUnits = hasViewportUnits; }
392         bool fontSizeHasViewportUnits() const { return m_fontSizeHasViewportUnits; }
393
394         void cacheBorderAndBackground();
395         bool hasUAAppearance() const { return m_hasUAAppearance; }
396         BorderData borderData() const { return m_borderData; }
397         FillLayer backgroundData() const { return m_backgroundData; }
398         Color backgroundColor() const { return m_backgroundColor; }
399
400         const FontCascadeDescription& fontDescription() { return m_style->fontDescription(); }
401         const FontCascadeDescription& parentFontDescription() { return m_parentStyle->fontDescription(); }
402         void setFontDescription(const FontCascadeDescription& fontDescription) { m_fontDirty |= m_style->setFontDescription(fontDescription); }
403         void setZoom(float f) { m_fontDirty |= m_style->setZoom(f); }
404         void setEffectiveZoom(float f) { m_fontDirty |= m_style->setEffectiveZoom(f); }
405         void setWritingMode(WritingMode writingMode) { m_fontDirty |= m_style->setWritingMode(writingMode); }
406         void setTextOrientation(TextOrientation textOrientation) { m_fontDirty |= m_style->setTextOrientation(textOrientation); }
407
408         bool useSVGZoomRules() const { return m_element && m_element->isSVGElement(); }
409
410         Style::PendingResources& ensurePendingResources();
411         std::unique_ptr<Style::PendingResources> takePendingResources() { return WTFMove(m_pendingResources); }
412
413         const CSSToLengthConversionData& cssToLengthConversionData() const { return m_cssToLengthConversionData; }
414
415         CascadeLevel cascadeLevel() const { return m_cascadeLevel; }
416         void setCascadeLevel(CascadeLevel level) { m_cascadeLevel = level; }
417         
418         CascadedProperties* authorRollback() const { return m_authorRollback.get(); }
419         CascadedProperties* userRollback() const { return m_userRollback.get(); }
420         
421         void setAuthorRollback(std::unique_ptr<CascadedProperties>& rollback) { m_authorRollback = WTFMove(rollback); }
422         void setUserRollback(std::unique_ptr<CascadedProperties>& rollback) { m_userRollback = WTFMove(rollback); }
423
424         const SelectorFilter* selectorFilter() const { return m_selectorFilter; }
425         
426     private:
427         void updateConversionData();
428
429         const Element* m_element { nullptr };
430         std::unique_ptr<RenderStyle> m_style;
431         const RenderStyle* m_parentStyle { nullptr };
432         std::unique_ptr<RenderStyle> m_ownedParentStyle;
433         const RenderStyle* m_rootElementStyle { nullptr };
434
435         const RenderRegion* m_regionForStyling { nullptr };
436         
437         EInsideLink m_elementLinkState { NotInsideLink };
438
439         bool m_applyPropertyToRegularStyle { true };
440         bool m_applyPropertyToVisitedLinkStyle { false };
441         bool m_fontDirty { false };
442         bool m_fontSizeHasViewportUnits { false };
443         bool m_hasUAAppearance { false };
444
445         BorderData m_borderData;
446         FillLayer m_backgroundData { BackgroundFillLayer };
447         Color m_backgroundColor;
448
449         std::unique_ptr<Style::PendingResources> m_pendingResources;
450         CSSToLengthConversionData m_cssToLengthConversionData;
451         
452         CascadeLevel m_cascadeLevel { UserAgentLevel };
453         std::unique_ptr<CascadedProperties> m_authorRollback;
454         std::unique_ptr<CascadedProperties> m_userRollback;
455
456         const SelectorFilter* m_selectorFilter { nullptr };
457     };
458
459     State& state() { return m_state; }
460     const State& state() const { return m_state; }
461
462     RefPtr<StyleImage> styleImage(CSSPropertyID, CSSValue&);
463     Ref<StyleCachedImage> styleCachedImageFromValue(CSSPropertyID, CSSValue&);
464     Ref<StyleGeneratedImage> styleGeneratedImageFromValue(CSSPropertyID, CSSImageGeneratorValue&);
465
466     bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle(); }
467     bool applyPropertyToVisitedLinkStyle() const { return m_state.applyPropertyToVisitedLinkStyle(); }
468
469     CascadeLevel cascadeLevel() const { return m_state.cascadeLevel(); }
470     void setCascadeLevel(CascadeLevel level) { m_state.setCascadeLevel(level); }
471     
472     CascadedProperties* cascadedPropertiesForRollback(const MatchResult&);
473
474     CSSToStyleMap* styleMap() { return &m_styleMap; }
475     InspectorCSSOMWrappers& inspectorCSSOMWrappers() { return m_inspectorCSSOMWrappers; }
476     const FontCascadeDescription& fontDescription() { return m_state.fontDescription(); }
477     const FontCascadeDescription& parentFontDescription() { return m_state.parentFontDescription(); }
478     void setFontDescription(const FontCascadeDescription& fontDescription) { m_state.setFontDescription(fontDescription); }
479     void setZoom(float f) { m_state.setZoom(f); }
480     void setEffectiveZoom(float f) { m_state.setEffectiveZoom(f); }
481     void setWritingMode(WritingMode writingMode) { m_state.setWritingMode(writingMode); }
482     void setTextOrientation(TextOrientation textOrientation) { m_state.setTextOrientation(textOrientation); }
483
484 private:
485     void cacheBorderAndBackground();
486
487     void applyProperty(CSSPropertyID, CSSValue*, SelectorChecker::LinkMatchMask = SelectorChecker::MatchDefault, const MatchResult* = nullptr);
488     RefPtr<CSSValue> resolvedVariableValue(CSSPropertyID, const CSSVariableDependentValue&);
489
490     void applySVGProperty(CSSPropertyID, CSSValue*);
491
492     void loadPendingImages();
493
494     static unsigned computeMatchedPropertiesHash(const MatchedProperties*, unsigned size);
495     struct MatchedPropertiesCacheItem {
496         Vector<MatchedProperties> matchedProperties;
497         MatchRanges ranges;
498         std::unique_ptr<RenderStyle> renderStyle;
499         std::unique_ptr<RenderStyle> parentRenderStyle;
500     };
501     const MatchedPropertiesCacheItem* findFromMatchedPropertiesCache(unsigned hash, const MatchResult&);
502     void addToMatchedPropertiesCache(const RenderStyle*, const RenderStyle* parentStyle, unsigned hash, const MatchResult&);
503
504     // Every N additions to the matched declaration cache trigger a sweep where entries holding
505     // the last reference to a style declaration are garbage collected.
506     void sweepMatchedPropertiesCache();
507
508     unsigned m_matchedPropertiesCacheAdditionsSinceLastSweep;
509
510     typedef HashMap<unsigned, MatchedPropertiesCacheItem> MatchedPropertiesCache;
511     MatchedPropertiesCache m_matchedPropertiesCache;
512
513     Timer m_matchedPropertiesCacheSweepTimer;
514
515     MediaQueryEvaluator m_mediaQueryEvaluator;
516     std::unique_ptr<RenderStyle> m_rootDefaultStyle;
517
518     Document& m_document;
519
520     bool m_matchAuthorAndUserStyles;
521
522     RenderStyle* m_overrideDocumentElementStyle { nullptr };
523
524     Vector<MediaQueryResult> m_viewportDependentMediaQueryResults;
525
526 #if ENABLE(CSS_DEVICE_ADAPTATION)
527     RefPtr<ViewportStyleResolver> m_viewportStyleResolver;
528 #endif
529
530     CSSToStyleMap m_styleMap;
531     InspectorCSSOMWrappers m_inspectorCSSOMWrappers;
532
533     State m_state;
534
535     // Try to catch a crash. https://bugs.webkit.org/show_bug.cgi?id=141561.
536     bool m_inLoadPendingImages { false };
537
538     friend bool operator==(const MatchedProperties&, const MatchedProperties&);
539     friend bool operator!=(const MatchedProperties&, const MatchedProperties&);
540     friend bool operator==(const MatchRanges&, const MatchRanges&);
541     friend bool operator!=(const MatchRanges&, const MatchRanges&);
542 };
543
544 inline bool StyleResolver::hasSelectorForAttribute(const Element& element, const AtomicString &attributeName) const
545 {
546     ASSERT(!attributeName.isEmpty());
547     if (element.isHTMLElement())
548         return m_ruleSets.features().attributeCanonicalLocalNamesInRules.contains(attributeName.impl());
549     return m_ruleSets.features().attributeLocalNamesInRules.contains(attributeName.impl());
550 }
551
552 inline bool StyleResolver::hasSelectorForClass(const AtomicString& classValue) const
553 {
554     ASSERT(!classValue.isEmpty());
555     return m_ruleSets.features().classesInRules.contains(classValue.impl());
556 }
557
558 inline bool StyleResolver::hasSelectorForId(const AtomicString& idValue) const
559 {
560     ASSERT(!idValue.isEmpty());
561     return m_ruleSets.features().idsInRules.contains(idValue.impl());
562 }
563
564 inline bool checkRegionSelector(const CSSSelector* regionSelector, const Element* regionElement)
565 {
566     if (!regionSelector || !regionElement)
567         return false;
568
569     SelectorChecker selectorChecker(regionElement->document());
570     for (const CSSSelector* s = regionSelector; s; s = CSSSelectorList::next(s)) {
571         SelectorChecker::CheckingContext selectorCheckingContext(SelectorChecker::Mode::QueryingRules);
572         unsigned ignoredSpecificity;
573         if (selectorChecker.match(*s, *regionElement, selectorCheckingContext, ignoredSpecificity))
574             return true;
575     }
576     return false;
577 }
578
579 } // namespace WebCore