Gesture tap highlighting entire first line
[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 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 "CSSRule.h"
26 #include "CSSToStyleMap.h"
27 #include "CSSValueList.h"
28 #include "LinkHash.h"
29 #include "MediaQueryExp.h"
30 #include "RenderStyle.h"
31 #include "SelectorChecker.h"
32 #include "StyleInheritedData.h"
33 #include <wtf/HashMap.h>
34 #include <wtf/HashSet.h>
35 #include <wtf/RefPtr.h>
36 #include <wtf/Vector.h>
37 #include <wtf/text/AtomicStringHash.h>
38 #include <wtf/text/StringHash.h>
39
40 namespace WebCore {
41
42 enum ESmartMinimumForFontSize { DoNotUseSmartMinimumForFontSize, UseSmartMinimumForFontFize };
43
44 class CSSFontSelector;
45 class CSSPageRule;
46 class CSSPrimitiveValue;
47 class CSSProperty;
48 class CSSRuleList;
49 class CSSFontFace;
50 class CSSFontFaceRule;
51 class CSSImageGeneratorValue;
52 class CSSImageSetValue;
53 class CSSImageValue;
54 class CSSSelector;
55 class CSSStyleRule;
56 class CSSStyleSheet;
57 class CSSValue;
58 class ContainerNode;
59 class CustomFilterOperation;
60 class CustomFilterParameter;
61 class Document;
62 class Element;
63 class Frame;
64 class FrameView;
65 class KURL;
66 class KeyframeList;
67 class KeyframeValue;
68 class MediaQueryEvaluator;
69 class Node;
70 class RenderRegion;
71 class RuleData;
72 class RuleSet;
73 class Settings;
74 class StaticCSSRuleList;
75 class StyleBuilder;
76 class StyleImage;
77 class StyleKeyframe;
78 class StylePendingImage;
79 class StylePropertySet;
80 class StyleRule;
81 class StyleRuleKeyframes;
82 class StyleRulePage;
83 class StyleRuleRegion;
84 class StyleShader;
85 class StyleSheet;
86 class StyleSheetContents;
87 class StyleSheetList;
88 class StyledElement;
89 class WebKitCSSFilterValue;
90 class WebKitCSSShaderValue;
91 class WebKitCSSSVGDocumentValue;
92
93 #if ENABLE(CSS_SHADERS)
94 typedef Vector<RefPtr<CustomFilterParameter> > CustomFilterParameterList;
95 #endif
96
97 class MediaQueryResult {
98     WTF_MAKE_NONCOPYABLE(MediaQueryResult); WTF_MAKE_FAST_ALLOCATED;
99 public:
100     MediaQueryResult(const MediaQueryExp& expr, bool result)
101         : m_expression(expr)
102         , m_result(result)
103     {
104     }
105     void reportMemoryUsage(MemoryObjectInfo*) const;
106
107     MediaQueryExp m_expression;
108     bool m_result;
109 };
110
111 enum StyleSharingBehavior {
112     AllowStyleSharing,
113     DisallowStyleSharing,
114 };
115
116 // MatchOnlyUserAgentRules is used in media queries, where relative units
117 // are interpreted according to the document root element style, and styled only
118 // from the User Agent Stylesheet rules.
119
120 enum RuleMatchingBehavior {
121     MatchAllRules,
122     MatchAllRulesExcludingSMIL,
123     MatchOnlyUserAgentRules,
124 };
125
126 // This class selects a RenderStyle for a given element based on a collection of stylesheets.
127 class StyleResolver {
128     WTF_MAKE_NONCOPYABLE(StyleResolver); WTF_MAKE_FAST_ALLOCATED;
129 public:
130     StyleResolver(Document*, bool matchAuthorAndUserStyles);
131     ~StyleResolver();
132
133     // Using these during tree walk will allow style selector to optimize child and descendant selector lookups.
134     void pushParentElement(Element*);
135     void popParentElement(Element*);
136     void pushParentShadowRoot(const ShadowRoot*);
137     void popParentShadowRoot(const ShadowRoot*);
138
139     PassRefPtr<RenderStyle> styleForElement(Element*, RenderStyle* parentStyle = 0, StyleSharingBehavior = AllowStyleSharing,
140         RuleMatchingBehavior = MatchAllRules, RenderRegion* regionForStyling = 0);
141
142     void keyframeStylesForAnimation(Element*, const RenderStyle*, KeyframeList&);
143
144     PassRefPtr<RenderStyle> pseudoStyleForElement(PseudoId, Element*, RenderStyle* parentStyle);
145
146     PassRefPtr<RenderStyle> styleForPage(int pageIndex);
147
148     static PassRefPtr<RenderStyle> styleForDocument(Document*, CSSFontSelector* = 0);
149
150     RenderStyle* style() const { return m_style.get(); }
151     RenderStyle* parentStyle() const { return m_parentStyle; }
152     RenderStyle* rootElementStyle() const { return m_rootElementStyle; }
153     Element* element() const { return m_element; }
154     Document* document() const { return m_checker.document(); }
155     const FontDescription& fontDescription() { return style()->fontDescription(); }
156     const FontDescription& parentFontDescription() { return parentStyle()->fontDescription(); }
157     void setFontDescription(const FontDescription& fontDescription) { m_fontDirty |= style()->setFontDescription(fontDescription); }
158     void setZoom(float f) { m_fontDirty |= style()->setZoom(f); }
159     void setEffectiveZoom(float f) { m_fontDirty |= style()->setEffectiveZoom(f); }
160     void setTextSizeAdjust(bool b) { m_fontDirty |= style()->setTextSizeAdjust(b); }
161     bool hasParentNode() const { return m_parentNode; }
162     
163     void appendAuthorStylesheets(unsigned firstNew, const Vector<RefPtr<StyleSheet> >&);
164     
165     // Find the ids or classes the selectors on a stylesheet are scoped to. The selectors only apply to elements in subtrees where the root element matches the scope.
166     static bool determineStylesheetSelectorScopes(StyleSheetContents*, HashSet<AtomicStringImpl*>& idScopes, HashSet<AtomicStringImpl*>& classScopes);
167
168 private:
169     void initForStyleResolve(Element*, RenderStyle* parentStyle = 0, PseudoId = NOPSEUDO);
170     void initElement(Element*);
171     void collectFeatures();
172     RenderStyle* locateSharedStyle();
173     bool matchesRuleSet(RuleSet*);
174     Node* locateCousinList(Element* parent, unsigned& visitedNodeCount) const;
175     StyledElement* findSiblingForStyleSharing(Node*, unsigned& count) const;
176     bool canShareStyleWithElement(StyledElement*) const;
177
178     PassRefPtr<RenderStyle> styleForKeyframe(const RenderStyle*, const StyleKeyframe*, KeyframeValue&);
179
180 #if ENABLE(STYLE_SCOPED)
181     void pushScope(const ContainerNode* scope, const ContainerNode* scopeParent);
182     void popScope(const ContainerNode* scope);
183 #else
184     void pushScope(const ContainerNode*, const ContainerNode*) { }
185     void popScope(const ContainerNode*) { }
186 #endif
187
188 public:
189     // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
190     enum CSSRuleFilter {
191         UAAndUserCSSRules   = 1 << 1,
192         AuthorCSSRules      = 1 << 2,
193         EmptyCSSRules       = 1 << 3,
194         CrossOriginCSSRules = 1 << 4,
195         AllButEmptyCSSRules = UAAndUserCSSRules | AuthorCSSRules | CrossOriginCSSRules,
196         AllCSSRules         = AllButEmptyCSSRules | EmptyCSSRules,
197     };
198     PassRefPtr<CSSRuleList> styleRulesForElement(Element*, unsigned rulesToInclude = AllButEmptyCSSRules);
199     PassRefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, PseudoId, unsigned rulesToInclude = AllButEmptyCSSRules);
200
201     // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
202     // the correct font size scaled relative to the user's default (medium).
203     static float fontSizeForKeyword(Document*, int keyword, bool shouldUseFixedDefaultSize);
204
205     // Given a font size in pixel, this function will return legacy font size between 1 and 7.
206     static int legacyFontSize(Document*, int pixelFontSize, bool shouldUseFixedDefaultSize);
207
208 public:
209     void applyPropertyToStyle(CSSPropertyID, CSSValue*, RenderStyle*);
210
211     void applyPropertyToCurrentStyle(CSSPropertyID, CSSValue*);
212
213     void updateFont();
214     void initializeFontStyle(Settings*);
215
216     static float getComputedSizeFromSpecifiedSize(Document*, float zoomFactor, bool isAbsoluteSize, float specifiedSize, ESmartMinimumForFontSize = UseSmartMinimumForFontFize);
217
218     void setFontSize(FontDescription&, float size);
219
220 private:
221     static float getComputedSizeFromSpecifiedSize(Document*, RenderStyle*, bool isAbsoluteSize, float specifiedSize, bool useSVGZoomRules);
222
223 public:
224     bool useSVGZoomRules();
225
226     static bool colorFromPrimitiveValueIsDerivedFromElement(CSSPrimitiveValue*);
227     Color colorFromPrimitiveValue(CSSPrimitiveValue*, bool forVisitedLink = false) const;
228
229     bool hasSelectorForAttribute(const AtomicString&) const;
230
231     CSSFontSelector* fontSelector() const { return m_fontSelector.get(); }
232
233     void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
234
235     bool affectedByViewportChange() const;
236
237     void allVisitedStateChanged() { m_checker.allVisitedStateChanged(); }
238     void visitedStateChanged(LinkHash visitedHash) { m_checker.visitedStateChanged(visitedHash); }
239
240     void addKeyframeStyle(PassRefPtr<StyleRuleKeyframes>);
241
242     bool checkRegionStyle(Element* regionElement);
243
244     bool usesSiblingRules() const { return !m_features.siblingRules.isEmpty(); }
245     bool usesFirstLineRules() const { return m_features.usesFirstLineRules; }
246     bool usesBeforeAfterRules() const { return m_features.usesBeforeAfterRules; }
247
248     static bool createTransformOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, TransformOperations& outOperations);
249     
250     void invalidateMatchedPropertiesCache();
251     
252     // WARNING. This will construct CSSOM wrappers for all style rules and cache then in a map for significant memory cost.
253     // It is here to support inspector. Don't use for any regular engine functions.
254     CSSStyleRule* ensureFullCSSOMWrapperForInspector(StyleRule*);
255
256 #if ENABLE(CSS_FILTERS)
257     bool createFilterOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, FilterOperations& outOperations);
258 #if ENABLE(CSS_SHADERS)
259     StyleShader* styleShader(CSSValue*);
260     StyleShader* cachedOrPendingStyleShaderFromValue(WebKitCSSShaderValue*);
261     bool parseCustomFilterParameterList(CSSValue*, CustomFilterParameterList&);
262     PassRefPtr<CustomFilterParameter> parseCustomFilterParameter(const String& name, CSSValue*);
263     PassRefPtr<CustomFilterParameter> parseCustomFilterArrayParameter(const String& name, CSSValueList*);
264     PassRefPtr<CustomFilterParameter> parseCustomFilterNumberParameter(const String& name, CSSValueList*);
265     PassRefPtr<CustomFilterParameter> parseCustomFilterTransformParameter(const String& name, CSSValueList*);
266     PassRefPtr<CustomFilterOperation> createCustomFilterOperation(WebKitCSSFilterValue*);
267     void loadPendingShaders();
268 #endif
269 #if ENABLE(SVG)
270     void loadPendingSVGDocuments();
271 #endif
272 #endif // ENABLE(CSS_FILTERS)
273
274     void loadPendingResources();
275
276     struct RuleFeature {
277         RuleFeature(StyleRule* rule, unsigned selectorIndex, bool hasDocumentSecurityOrigin)
278             : rule(rule)
279             , selectorIndex(selectorIndex)
280             , hasDocumentSecurityOrigin(hasDocumentSecurityOrigin) 
281         { 
282         }
283         StyleRule* rule;
284         unsigned selectorIndex;
285         bool hasDocumentSecurityOrigin;
286     };
287     struct Features {
288         Features();
289         ~Features();
290         void add(const StyleResolver::Features&);
291         void clear();
292         void reportMemoryUsage(MemoryObjectInfo*) const;
293         HashSet<AtomicStringImpl*> idsInRules;
294         HashSet<AtomicStringImpl*> attrsInRules;
295         Vector<RuleFeature> siblingRules;
296         Vector<RuleFeature> uncommonAttributeRules;
297         bool usesFirstLineRules;
298         bool usesBeforeAfterRules;
299     };
300
301 private:
302     // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
303     void checkForGenericFamilyChange(RenderStyle*, RenderStyle* parentStyle);
304     void checkForZoomChange(RenderStyle*, RenderStyle* parentStyle);
305     void checkForTextSizeAdjust();
306
307     void adjustRenderStyle(RenderStyle* styleToAdjust, RenderStyle* parentStyle, Element*);
308
309     void addMatchedRule(const RuleData* rule) { m_matchedRules.append(rule); }
310
311     struct MatchRanges {
312         MatchRanges() : firstUARule(-1), lastUARule(-1), firstAuthorRule(-1), lastAuthorRule(-1), firstUserRule(-1), lastUserRule(-1) { }
313         int firstUARule;
314         int lastUARule;
315         int firstAuthorRule;
316         int lastAuthorRule;
317         int firstUserRule;
318         int lastUserRule;
319     };
320
321     struct MatchedProperties {
322         MatchedProperties() : possiblyPaddedMember(0) { }
323         void reportMemoryUsage(MemoryObjectInfo*) const;
324         
325         RefPtr<StylePropertySet> properties;
326         union {
327             struct {
328                 unsigned linkMatchType : 2;
329                 unsigned isInRegionRule : 1;
330             };
331             // Used to make sure all memory is zero-initialized since we compute the hash over the bytes of this object.
332             void* possiblyPaddedMember;
333         };
334     };
335
336     struct MatchResult {
337         MatchResult() : isCacheable(true) { }
338         Vector<MatchedProperties, 64> matchedProperties;
339         Vector<StyleRule*, 64> matchedRules;
340         MatchRanges ranges;
341         bool isCacheable;
342     };
343
344     struct MatchOptions {
345         MatchOptions(bool includeEmptyRules, const ContainerNode* scope = 0) : scope(scope), includeEmptyRules(includeEmptyRules) { }
346         const ContainerNode* scope;
347         bool includeEmptyRules;
348     };
349
350     static void addMatchedProperties(MatchResult&, const StylePropertySet* properties, StyleRule* = 0, unsigned linkMatchType = SelectorChecker::MatchAll, bool inRegionRule = false);
351     void addElementStyleProperties(MatchResult&, const StylePropertySet*, bool isCacheable = true);
352
353     void matchAllRules(MatchResult&, bool includeSMILProperties);
354     void matchUARules(MatchResult&);
355     void matchUARules(MatchResult&, RuleSet*);
356     void matchAuthorRules(MatchResult&, bool includeEmptyRules);
357     void matchUserRules(MatchResult&, bool includeEmptyRules);
358     void matchScopedAuthorRules(MatchResult&, bool includeEmptyRules);
359     void collectMatchingRules(RuleSet*, int& firstRuleIndex, int& lastRuleIndex, const MatchOptions&);
360     void collectMatchingRulesForRegion(RuleSet*, int& firstRuleIndex, int& lastRuleIndex, const MatchOptions&);
361     void collectMatchingRulesForList(const Vector<RuleData>*, int& firstRuleIndex, int& lastRuleIndex, const MatchOptions&);
362     bool fastRejectSelector(const RuleData&) const;
363     void sortMatchedRules();
364     void sortAndTransferMatchedRules(MatchResult&);
365
366     bool checkSelector(const RuleData&, const ContainerNode* scope = 0);
367     bool checkRegionSelector(CSSSelector* regionSelector, Element* regionElement);
368     void applyMatchedProperties(const MatchResult&, const Element*);
369     enum StyleApplicationPass {
370 #if ENABLE(CSS_VARIABLES)
371         VariableDefinitions,
372 #endif
373         HighPriorityProperties,
374         LowPriorityProperties
375     };
376     template <StyleApplicationPass pass>
377     void applyMatchedProperties(const MatchResult&, bool important, int startIndex, int endIndex, bool inheritedOnly);
378     template <StyleApplicationPass pass>
379     void applyProperties(const StylePropertySet* properties, StyleRule*, bool isImportant, bool inheritedOnly, bool filterRegionProperties);
380 #if ENABLE(CSS_VARIABLES)
381     void resolveVariables(CSSPropertyID, CSSValue*, Vector<std::pair<CSSPropertyID, String> >& knownExpressions);
382 #endif
383     static bool isValidRegionStyleProperty(CSSPropertyID);
384
385     void matchPageRules(MatchResult&, RuleSet*, bool isLeftPage, bool isFirstPage, const String& pageName);
386     void matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>&, bool isLeftPage, bool isFirstPage, const String& pageName);
387     Settings* documentSettings() { return m_checker.document()->settings(); }
388
389     bool isLeftPage(int pageIndex) const;
390     bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
391     bool isFirstPage(int pageIndex) const;
392     String pageName(int pageIndex) const;
393
394     OwnPtr<RuleSet> m_authorStyle;
395     OwnPtr<RuleSet> m_userStyle;
396
397     Features m_features;
398     OwnPtr<RuleSet> m_siblingRuleSet;
399     OwnPtr<RuleSet> m_uncommonAttributeRuleSet;
400
401     bool m_hasUAAppearance;
402     BorderData m_borderData;
403     FillLayer m_backgroundData;
404     Color m_backgroundColor;
405
406     typedef HashMap<AtomicStringImpl*, RefPtr<StyleRuleKeyframes> > KeyframesRuleMap;
407     KeyframesRuleMap m_keyframesRuleMap;
408
409 public:
410     static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
411
412     PassRefPtr<StyleImage> styleImage(CSSPropertyID, CSSValue*);
413     PassRefPtr<StyleImage> cachedOrPendingFromValue(CSSPropertyID, CSSImageValue*);
414     PassRefPtr<StyleImage> generatedOrPendingFromValue(CSSPropertyID, CSSImageGeneratorValue*);
415 #if ENABLE(CSS_IMAGE_SET)
416     PassRefPtr<StyleImage> setOrPendingFromValue(CSSPropertyID, CSSImageSetValue*);
417 #endif
418
419     bool applyPropertyToRegularStyle() const { return m_applyPropertyToRegularStyle; }
420     bool applyPropertyToVisitedLinkStyle() const { return m_applyPropertyToVisitedLinkStyle; }
421
422     static Length convertToIntLength(CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, double multiplier = 1);
423     static Length convertToFloatLength(CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, double multiplier = 1);
424
425     CSSToStyleMap* styleMap() { return &m_styleMap; }
426
427     void reportMemoryUsage(MemoryObjectInfo*) const;
428     
429 private:
430     static RenderStyle* s_styleNotYetAvailable;
431
432     void addStylesheetsFromSeamlessParents();
433     void addAuthorRulesAndCollectUserRulesFromSheets(const Vector<RefPtr<CSSStyleSheet> >*, RuleSet& userStyle);
434
435     void cacheBorderAndBackground();
436
437 private:
438     bool canShareStyleWithControl(StyledElement*) const;
439
440     void applyProperty(CSSPropertyID, CSSValue*);
441
442 #if ENABLE(SVG)
443     void applySVGProperty(CSSPropertyID, CSSValue*);
444 #endif
445
446     PassRefPtr<StyleImage> loadPendingImage(StylePendingImage*);
447     void loadPendingImages();
448
449     static unsigned computeMatchedPropertiesHash(const MatchedProperties*, unsigned size);
450     struct MatchedPropertiesCacheItem {
451         void reportMemoryUsage(MemoryObjectInfo*) const;
452         Vector<MatchedProperties> matchedProperties;
453         MatchRanges ranges;
454         RefPtr<RenderStyle> renderStyle;
455         RefPtr<RenderStyle> parentRenderStyle;
456     };
457     const MatchedPropertiesCacheItem* findFromMatchedPropertiesCache(unsigned hash, const MatchResult&);
458     void addToMatchedPropertiesCache(const RenderStyle*, const RenderStyle* parentStyle, unsigned hash, const MatchResult&);
459
460     // Every N additions to the matched declaration cache trigger a sweep where entries holding
461     // the last reference to a style declaration are garbage collected.
462     void sweepMatchedPropertiesCache();
463
464     unsigned m_matchedPropertiesCacheAdditionsSinceLastSweep;
465
466     typedef HashMap<unsigned, MatchedPropertiesCacheItem> MatchedPropertiesCache;
467     MatchedPropertiesCache m_matchedPropertiesCache;
468
469     // A buffer used to hold the set of matched rules for an element, and a temporary buffer used for
470     // merge sorting.
471     Vector<const RuleData*, 32> m_matchedRules;
472
473     RefPtr<StaticCSSRuleList> m_ruleList;
474
475     typedef HashMap<CSSPropertyID, RefPtr<CSSValue> > PendingImagePropertyMap;
476     PendingImagePropertyMap m_pendingImageProperties;
477
478     OwnPtr<MediaQueryEvaluator> m_medium;
479     RefPtr<RenderStyle> m_rootDefaultStyle;
480
481     PseudoId m_dynamicPseudo;
482     PseudoId m_pseudoStyle;
483
484     SelectorChecker m_checker;
485
486     RefPtr<RenderStyle> m_style;
487     RenderStyle* m_parentStyle;
488     RenderStyle* m_rootElementStyle;
489     Element* m_element;
490     StyledElement* m_styledElement;
491     RenderRegion* m_regionForStyling;
492     EInsideLink m_elementLinkState;
493     ContainerNode* m_parentNode;
494     CSSValue* m_lineHeightValue;
495     bool m_fontDirty;
496     bool m_matchAuthorAndUserStyles;
497     bool m_sameOriginOnly;
498     bool m_distributedToInsertionPoint;
499     bool m_hasUnknownPseudoElements;
500
501     RefPtr<CSSFontSelector> m_fontSelector;
502     Vector<OwnPtr<MediaQueryResult> > m_viewportDependentMediaQueryResults;
503
504     bool m_applyPropertyToRegularStyle;
505     bool m_applyPropertyToVisitedLinkStyle;
506     const StyleBuilder& m_styleBuilder;
507     
508     HashMap<StyleRule*, RefPtr<CSSStyleRule> > m_styleRuleToCSSOMWrapperMap;
509     HashSet<RefPtr<CSSStyleSheet> > m_styleSheetCSSOMWrapperSet;
510
511 #if ENABLE(CSS_SHADERS)
512     bool m_hasPendingShaders;
513 #endif
514
515 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
516     HashMap<FilterOperation*, RefPtr<WebKitCSSSVGDocumentValue> > m_pendingSVGDocuments;
517 #endif
518
519 #if ENABLE(STYLE_SCOPED)
520     const ContainerNode* determineScope(const CSSStyleSheet*);
521
522     typedef HashMap<const ContainerNode*, OwnPtr<RuleSet> > ScopedRuleSetMap;
523
524     RuleSet* ruleSetForScope(const ContainerNode*) const;
525
526     void setupScopeStack(const ContainerNode*);
527     bool scopeStackIsConsistent(const ContainerNode* parent) const { return parent && parent == m_scopeStackParent; }
528
529     ScopedRuleSetMap m_scopedAuthorStyles;
530     
531     struct ScopeStackFrame {
532         ScopeStackFrame() : m_scope(0), m_authorStyleBoundsIndex(0), m_ruleSet(0) { }
533         ScopeStackFrame(const ContainerNode* scope, int authorStyleBoundsIndex, RuleSet* ruleSet) : m_scope(scope), m_authorStyleBoundsIndex(authorStyleBoundsIndex), m_ruleSet(ruleSet) { }
534         const ContainerNode* m_scope;
535         int m_authorStyleBoundsIndex;
536         RuleSet* m_ruleSet;
537     };
538     // Vector (used as stack) that keeps track of scoping elements (i.e., elements with a <style scoped> child)
539     // encountered during tree iteration for style resolution.
540     Vector<ScopeStackFrame> m_scopeStack;
541     // Element last seen as parent element when updating m_scopingElementStack.
542     // This is used to decide whether m_scopingElementStack is consistent, separately from SelectorChecker::m_parentStack.
543     const ContainerNode* m_scopeStackParent;
544     int m_scopeStackParentBoundsIndex;
545 #endif
546
547     CSSToStyleMap m_styleMap;
548
549     friend class StyleBuilder;
550     friend bool operator==(const MatchedProperties&, const MatchedProperties&);
551     friend bool operator!=(const MatchedProperties&, const MatchedProperties&);
552     friend bool operator==(const MatchRanges&, const MatchRanges&);
553     friend bool operator!=(const MatchRanges&, const MatchRanges&);
554 };
555
556 } // namespace WebCore
557
558 #endif // StyleResolver_h