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