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