e8ca3c07d3d1200438fb39c9e02950e2b3814de1
[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 "CSSRuleList.h"
27 #include "CSSToStyleMap.h"
28 #include "CSSValueList.h"
29 #include "DocumentRuleSets.h"
30 #include "InspectorCSSOMWrappers.h"
31 #include "LinkHash.h"
32 #include "MediaQueryExp.h"
33 #include "RenderStyle.h"
34 #include "RuleFeature.h"
35 #include "RuleSet.h"
36 #include "RuntimeEnabledFeatures.h"
37 #include "SelectorChecker.h"
38 #include "SelectorFilter.h"
39 #include "StyleInheritedData.h"
40 #include "StyleScopeResolver.h"
41 #include "ViewportStyleResolver.h"
42 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
43 #include "WebKitCSSSVGDocumentValue.h"
44 #endif
45 #include <wtf/HashMap.h>
46 #include <wtf/HashSet.h>
47 #include <wtf/RefPtr.h>
48 #include <wtf/Vector.h>
49 #include <wtf/text/AtomicStringHash.h>
50 #include <wtf/text/StringHash.h>
51
52 namespace WebCore {
53
54 enum ESmartMinimumForFontSize { DoNotUseSmartMinimumForFontSize, UseSmartMinimumForFontFize };
55
56 class CSSCursorImageValue;
57 class CSSFontSelector;
58 class CSSFontFace;
59 class CSSFontFaceRule;
60 class CSSImageGeneratorValue;
61 class CSSImageSetValue;
62 class CSSImageValue;
63 class CSSPageRule;
64 class CSSPrimitiveValue;
65 class CSSProperty;
66 class CSSRuleList;
67 class CSSSelector;
68 class CSSStyleSheet;
69 class CSSValue;
70 class ContainerNode;
71 class CustomFilterOperation;
72 class CustomFilterParameter;
73 class CustomFilterParameterList;
74 class Document;
75 class Element;
76 class Frame;
77 class FrameView;
78 class KURL;
79 class KeyframeList;
80 class KeyframeValue;
81 class MediaQueryEvaluator;
82 class Node;
83 class RenderRegion;
84 class RuleData;
85 class RuleSet;
86 class Settings;
87 class StaticCSSRuleList;
88 class StyleBuilder;
89 class StyleScopeResolver;
90 class StyleImage;
91 class StyleKeyframe;
92 class StylePendingImage;
93 class StylePropertySet;
94 class StyleRule;
95 #if ENABLE(SHADOW_DOM)
96 class StyleRuleHost;
97 #endif
98 class StyleRuleKeyframes;
99 class StyleRulePage;
100 class StyleRuleRegion;
101 class StyleShader;
102 class StyleSheet;
103 class StyleSheetList;
104 class StyledElement;
105 class ViewportStyleResolver;
106 class WebKitCSSFilterValue;
107 class WebKitCSSShaderValue;
108 class WebKitCSSSVGDocumentValue;
109
110 class MediaQueryResult {
111     WTF_MAKE_NONCOPYABLE(MediaQueryResult); WTF_MAKE_FAST_ALLOCATED;
112 public:
113     MediaQueryResult(const MediaQueryExp& expr, bool result)
114         : m_expression(expr)
115         , m_result(result)
116     {
117     }
118     void reportMemoryUsage(MemoryObjectInfo*) const;
119
120     MediaQueryExp m_expression;
121     bool m_result;
122 };
123
124 enum StyleSharingBehavior {
125     AllowStyleSharing,
126     DisallowStyleSharing,
127 };
128
129 // MatchOnlyUserAgentRules is used in media queries, where relative units
130 // are interpreted according to the document root element style, and styled only
131 // from the User Agent Stylesheet rules.
132
133 enum RuleMatchingBehavior {
134     MatchAllRules,
135     MatchAllRulesExcludingSMIL,
136     MatchOnlyUserAgentRules,
137 };
138
139 // This class selects a RenderStyle for a given element based on a collection of stylesheets.
140 class StyleResolver {
141     WTF_MAKE_NONCOPYABLE(StyleResolver); WTF_MAKE_FAST_ALLOCATED;
142 public:
143     StyleResolver(Document*, bool matchAuthorAndUserStyles);
144     ~StyleResolver();
145
146     // Using these during tree walk will allow style selector to optimize child and descendant selector lookups.
147     void pushParentElement(Element*);
148     void popParentElement(Element*);
149     void pushParentShadowRoot(const ShadowRoot*);
150     void popParentShadowRoot(const ShadowRoot*);
151 #if ENABLE(SHADOW_DOM)
152     void addHostRule(StyleRuleHost* rule, bool hasDocumentSecurityOrigin, const ContainerNode* scope) { ensureScopeResolver()->addHostRule(rule, hasDocumentSecurityOrigin, scope); }
153 #endif
154
155     PassRefPtr<RenderStyle> styleForElement(Element*, RenderStyle* parentStyle = 0, StyleSharingBehavior = AllowStyleSharing,
156         RuleMatchingBehavior = MatchAllRules, RenderRegion* regionForStyling = 0);
157
158     void keyframeStylesForAnimation(Element*, const RenderStyle*, KeyframeList&);
159
160     PassRefPtr<RenderStyle> pseudoStyleForElement(PseudoId, Element*, RenderStyle* parentStyle);
161
162     PassRefPtr<RenderStyle> styleForPage(int pageIndex);
163     PassRefPtr<RenderStyle> defaultStyleForElement();
164     PassRefPtr<RenderStyle> styleForText(Text*);
165
166     static PassRefPtr<RenderStyle> styleForDocument(Document*, CSSFontSelector* = 0);
167
168     RenderStyle* style() const { return m_state.style.get(); }
169     RenderStyle* parentStyle() const { return m_state.parentStyle; }
170     RenderStyle* rootElementStyle() const { return m_state.rootElementStyle; }
171     Element* element() const { return m_state.element; }
172     Document* document() const { return m_document; }
173     StyleScopeResolver* scopeResolver() const { return m_scopeResolver.get(); }
174     const FontDescription& fontDescription() { return style()->fontDescription(); }
175     const FontDescription& parentFontDescription() { return parentStyle()->fontDescription(); }
176     void setFontDescription(const FontDescription& fontDescription) { m_state.fontDirty |= style()->setFontDescription(fontDescription); }
177     void setZoom(float f) { m_state.fontDirty |= style()->setZoom(f); }
178     void setEffectiveZoom(float f) { m_state.fontDirty |= style()->setEffectiveZoom(f); }
179     void setTextSizeAdjust(bool b) { m_state.fontDirty |= style()->setTextSizeAdjust(b); }
180     void setWritingMode(WritingMode writingMode) { m_state.fontDirty |= style()->setWritingMode(writingMode); }
181     void setTextOrientation(TextOrientation textOrientation) { m_state.fontDirty |= style()->setTextOrientation(textOrientation); }
182     bool hasParentNode() const { return m_state.parentNode; }
183
184     // FIXME: It could be better to call m_ruleSets.appendAuthorStyleSheets() directly after we factor StyleRsolver further.
185     // https://bugs.webkit.org/show_bug.cgi?id=108890
186     void appendAuthorStyleSheets(unsigned firstNew, const Vector<RefPtr<CSSStyleSheet> >&);
187
188     DocumentRuleSets& ruleSets() { return m_ruleSets; }
189     const DocumentRuleSets& ruleSets() const { return m_ruleSets; }
190
191 #if ENABLE(STYLE_SCOPED) || ENABLE(SHADOW_DOM)
192     StyleScopeResolver* ensureScopeResolver()
193     {
194 #if ENABLE(STYLE_SCOPED)
195 #if ENABLE(SHADOW_DOM)
196         ASSERT(RuntimeEnabledFeatures::shadowDOMEnabled() || RuntimeEnabledFeatures::styleScopedEnabled());
197 #else
198         ASSERT(RuntimeEnabledFeatures::styleScopedEnabled());
199 #endif
200 #else
201         ASSERT(RuntimeEnabledFeatures::shadowDOMEnabled());
202 #endif
203         if (!m_scopeResolver)
204             m_scopeResolver = adoptPtr(new StyleScopeResolver());
205         return m_scopeResolver.get();
206     }
207 #endif
208
209 private:
210     void initForStyleResolve(Element*, RenderStyle* parentStyle = 0, PseudoId = NOPSEUDO);
211     void initElement(Element*);
212     RenderStyle* locateSharedStyle();
213     bool styleSharingCandidateMatchesRuleSet(RuleSet*);
214     bool styleSharingCandidateMatchesHostRules();
215     Node* locateCousinList(Element* parent, unsigned& visitedNodeCount) const;
216     StyledElement* findSiblingForStyleSharing(Node*, unsigned& count) const;
217     bool canShareStyleWithElement(StyledElement*) const;
218
219     PassRefPtr<RenderStyle> styleForKeyframe(const RenderStyle*, const StyleKeyframe*, KeyframeValue&);
220
221 public:
222     // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
223     enum CSSRuleFilter {
224         UAAndUserCSSRules   = 1 << 1,
225         AuthorCSSRules      = 1 << 2,
226         EmptyCSSRules       = 1 << 3,
227         CrossOriginCSSRules = 1 << 4,
228         AllButEmptyCSSRules = UAAndUserCSSRules | AuthorCSSRules | CrossOriginCSSRules,
229         AllCSSRules         = AllButEmptyCSSRules | EmptyCSSRules,
230     };
231     PassRefPtr<CSSRuleList> styleRulesForElement(Element*, unsigned rulesToInclude = AllButEmptyCSSRules);
232     PassRefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, PseudoId, unsigned rulesToInclude = AllButEmptyCSSRules);
233
234     // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
235     // the correct font size scaled relative to the user's default (medium).
236     static float fontSizeForKeyword(Document*, int keyword, bool shouldUseFixedDefaultSize);
237
238     // Given a font size in pixel, this function will return legacy font size between 1 and 7.
239     static int legacyFontSize(Document*, int pixelFontSize, bool shouldUseFixedDefaultSize);
240
241 public:
242     void applyPropertyToStyle(CSSPropertyID, CSSValue*, RenderStyle*);
243
244     void applyPropertyToCurrentStyle(CSSPropertyID, CSSValue*);
245
246     void updateFont();
247     void initializeFontStyle(Settings*);
248
249     static float getComputedSizeFromSpecifiedSize(Document*, float zoomFactor, bool isAbsoluteSize, float specifiedSize, ESmartMinimumForFontSize = UseSmartMinimumForFontFize);
250
251     void setFontSize(FontDescription&, float size);
252
253 private:
254     static float getComputedSizeFromSpecifiedSize(Document*, RenderStyle*, bool isAbsoluteSize, float specifiedSize, bool useSVGZoomRules);
255
256 public:
257     bool useSVGZoomRules();
258
259     static bool colorFromPrimitiveValueIsDerivedFromElement(CSSPrimitiveValue*);
260     Color colorFromPrimitiveValue(CSSPrimitiveValue*, bool forVisitedLink = false) const;
261
262     bool hasSelectorForId(const AtomicString&) const;
263     bool hasSelectorForClass(const AtomicString&) const;
264     bool hasSelectorForAttribute(const AtomicString&) const;
265
266     CSSFontSelector* fontSelector() const { return m_fontSelector.get(); }
267 #if ENABLE(CSS_DEVICE_ADAPTATION)
268     ViewportStyleResolver* viewportStyleResolver() { return m_viewportStyleResolver.get(); }
269 #endif
270
271     void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
272     bool hasViewportDependentMediaQueries() const { return !m_viewportDependentMediaQueryResults.isEmpty(); }
273     bool affectedByViewportChange() const;
274
275     void addKeyframeStyle(PassRefPtr<StyleRuleKeyframes>);
276
277     bool checkRegionStyle(Element* regionElement);
278
279     bool usesSiblingRules() const { return !m_ruleSets.features().siblingRules.isEmpty(); }
280     bool usesFirstLineRules() const { return m_ruleSets.features().usesFirstLineRules; }
281     bool usesBeforeAfterRules() const { return m_ruleSets.features().usesBeforeAfterRules; }
282
283     static bool createTransformOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, TransformOperations& outOperations);
284     
285     void invalidateMatchedPropertiesCache();
286
287 #if ENABLE(CSS_FILTERS)
288     bool createFilterOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, FilterOperations& outOperations);
289 #if ENABLE(CSS_SHADERS)
290     StyleShader* styleShader(CSSValue*);
291     StyleShader* cachedOrPendingStyleShaderFromValue(WebKitCSSShaderValue*);
292     bool parseCustomFilterParameterList(CSSValue*, CustomFilterParameterList&);
293     PassRefPtr<CustomFilterParameter> parseCustomFilterParameter(const String& name, CSSValue*);
294     PassRefPtr<CustomFilterParameter> parseCustomFilterArrayParameter(const String& name, CSSValueList*);
295     PassRefPtr<CustomFilterParameter> parseCustomFilterNumberParameter(const String& name, CSSValueList*);
296     PassRefPtr<CustomFilterParameter> parseCustomFilterTransformParameter(const String& name, CSSValueList*);
297     PassRefPtr<CustomFilterOperation> createCustomFilterOperationWithAtRuleReferenceSyntax(WebKitCSSFilterValue*);
298     PassRefPtr<CustomFilterOperation> createCustomFilterOperationWithInlineSyntax(WebKitCSSFilterValue*);
299     PassRefPtr<CustomFilterOperation> createCustomFilterOperation(WebKitCSSFilterValue*);
300     void loadPendingShaders();
301 #endif
302 #if ENABLE(SVG)
303     void loadPendingSVGDocuments();
304 #endif
305 #endif // ENABLE(CSS_FILTERS)
306
307     void loadPendingResources();
308
309 private:
310     // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
311     void checkForGenericFamilyChange(RenderStyle*, RenderStyle* parentStyle);
312     void checkForZoomChange(RenderStyle*, RenderStyle* parentStyle);
313     void checkForTextSizeAdjust();
314
315     void adjustRenderStyle(RenderStyle* styleToAdjust, RenderStyle* parentStyle, Element*);
316
317     void addMatchedRule(const RuleData* rule) { m_state.matchedRules.append(rule); }
318
319     struct RuleRange {
320         RuleRange(int& firstRuleIndex, int& lastRuleIndex): firstRuleIndex(firstRuleIndex), lastRuleIndex(lastRuleIndex) { }
321         int& firstRuleIndex;
322         int& lastRuleIndex;
323     };
324
325     struct MatchRanges {
326         MatchRanges() : firstUARule(-1), lastUARule(-1), firstAuthorRule(-1), lastAuthorRule(-1), firstUserRule(-1), lastUserRule(-1) { }
327         int firstUARule;
328         int lastUARule;
329         int firstAuthorRule;
330         int lastAuthorRule;
331         int firstUserRule;
332         int lastUserRule;
333         RuleRange UARuleRange() { return RuleRange(firstUARule, lastUARule); }
334         RuleRange authorRuleRange() { return RuleRange(firstAuthorRule, lastAuthorRule); }
335         RuleRange userRuleRange() { return RuleRange(firstUserRule, lastUserRule); }
336     };
337
338     struct MatchedProperties {
339         MatchedProperties() : possiblyPaddedMember(0) { }
340         void reportMemoryUsage(MemoryObjectInfo*) const;
341         
342         RefPtr<StylePropertySet> properties;
343         union {
344             struct {
345                 unsigned linkMatchType : 2;
346                 unsigned whitelistType : 2;
347             };
348             // Used to make sure all memory is zero-initialized since we compute the hash over the bytes of this object.
349             void* possiblyPaddedMember;
350         };
351     };
352
353     struct MatchResult {
354         MatchResult() : isCacheable(true) { }
355         Vector<MatchedProperties, 64> matchedProperties;
356         Vector<StyleRule*, 64> matchedRules;
357         MatchRanges ranges;
358         bool isCacheable;
359     };
360
361     struct MatchRequest {
362         MatchRequest(RuleSet* ruleSet, bool includeEmptyRules = false, const ContainerNode* scope = 0)
363             : ruleSet(ruleSet)
364             , includeEmptyRules(includeEmptyRules)
365             , scope(scope) { }
366         const RuleSet* ruleSet;
367         const bool includeEmptyRules;
368         const ContainerNode* scope;
369     };
370
371     static void addMatchedProperties(MatchResult&, const StylePropertySet* properties, StyleRule* = 0, unsigned linkMatchType = SelectorChecker::MatchAll, PropertyWhitelistType = PropertyWhitelistNone);
372     void addElementStyleProperties(MatchResult&, const StylePropertySet*, bool isCacheable = true);
373
374     void matchAllRules(MatchResult&, bool includeSMILProperties);
375     void matchUARules(MatchResult&);
376     void matchUARules(MatchResult&, RuleSet*);
377     void matchAuthorRules(MatchResult&, bool includeEmptyRules);
378     void matchUserRules(MatchResult&, bool includeEmptyRules);
379     void matchScopedAuthorRules(MatchResult&, bool includeEmptyRules);
380     void matchHostRules(MatchResult&, bool includeEmptyRules);
381
382     void collectMatchingRules(const MatchRequest&, RuleRange&);
383     void collectMatchingRulesForRegion(const MatchRequest&, RuleRange&);
384     void collectMatchingRulesForList(const Vector<RuleData>*, const MatchRequest&, RuleRange&);
385
386     bool fastRejectSelector(const RuleData&) const;
387     void sortMatchedRules();
388     void sortAndTransferMatchedRules(MatchResult&);
389
390     bool ruleMatches(const RuleData&, const ContainerNode* scope);
391     bool checkRegionSelector(const CSSSelector* regionSelector, Element* regionElement);
392     void applyMatchedProperties(const MatchResult&, const Element*);
393     enum StyleApplicationPass {
394 #if ENABLE(CSS_VARIABLES)
395         VariableDefinitions,
396 #endif
397         HighPriorityProperties,
398         LowPriorityProperties
399     };
400     template <StyleApplicationPass pass>
401     void applyMatchedProperties(const MatchResult&, bool important, int startIndex, int endIndex, bool inheritedOnly);
402     template <StyleApplicationPass pass>
403     void applyProperties(const StylePropertySet* properties, StyleRule*, bool isImportant, bool inheritedOnly, PropertyWhitelistType = PropertyWhitelistNone);
404 #if ENABLE(CSS_VARIABLES)
405     void resolveVariables(CSSPropertyID, CSSValue*, Vector<std::pair<CSSPropertyID, String> >& knownExpressions);
406 #endif
407     static bool isValidRegionStyleProperty(CSSPropertyID);
408 #if ENABLE(VIDEO_TRACK)
409     static bool isValidCueStyleProperty(CSSPropertyID);
410 #endif
411     void matchPageRules(MatchResult&, RuleSet*, bool isLeftPage, bool isFirstPage, const String& pageName);
412     void matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>&, bool isLeftPage, bool isFirstPage, const String& pageName);
413     Settings* documentSettings() { return m_document->settings(); }
414
415     bool isLeftPage(int pageIndex) const;
416     bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
417     bool isFirstPage(int pageIndex) const;
418     String pageName(int pageIndex) const;
419
420     DocumentRuleSets m_ruleSets;
421
422     typedef HashMap<AtomicStringImpl*, RefPtr<StyleRuleKeyframes> > KeyframesRuleMap;
423     KeyframesRuleMap m_keyframesRuleMap;
424
425 public:
426     typedef HashMap<CSSPropertyID, RefPtr<CSSValue> > PendingImagePropertyMap;
427 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
428     typedef HashMap<FilterOperation*, RefPtr<WebKitCSSSVGDocumentValue> > PendingSVGDocumentMap;
429 #endif
430
431     class State {
432         WTF_MAKE_NONCOPYABLE(State);
433     public:
434         State()
435         : element(0)
436         , styledElement(0)
437         , parentNode(0)
438         , parentStyle(0)
439         , rootElementStyle(0)
440         , regionForStyling(0)
441         , sameOriginOnly(false)
442         , pseudoStyle(NOPSEUDO)
443         , elementLinkState(NotInsideLink)
444         , distributedToInsertionPoint(false)
445         , elementAffectedByClassRules(false)
446         , applyPropertyToRegularStyle(true)
447         , applyPropertyToVisitedLinkStyle(false)
448 #if ENABLE(CSS_SHADERS)
449         , hasPendingShaders(false)
450 #endif
451         , lineHeightValue(0)
452         , fontDirty(false)
453         , hasUAAppearance(false)
454         , backgroundData(BackgroundFillLayer) { }
455         
456 public:
457         // FIXME(bug 108563): to make it easier to review, these member
458         // variables are public. However we should add methods to access
459         // these variables.
460         Element* element;
461         RefPtr<RenderStyle> style;
462         StyledElement* styledElement;
463         ContainerNode* parentNode;
464         RenderStyle* parentStyle;
465         RenderStyle* rootElementStyle;
466         
467         RenderRegion* regionForStyling;
468         bool sameOriginOnly;
469         PseudoId pseudoStyle;
470
471         EInsideLink elementLinkState;
472
473         bool distributedToInsertionPoint;
474
475         bool elementAffectedByClassRules;
476
477         PseudoId dynamicPseudo;
478
479         // A buffer used to hold the set of matched rules for an element,
480         // and a temporary buffer used for merge sorting.
481         Vector<const RuleData*, 32> matchedRules;
482         RefPtr<StaticCSSRuleList> ruleList;
483
484         bool applyPropertyToRegularStyle;
485         bool applyPropertyToVisitedLinkStyle;
486
487         PendingImagePropertyMap pendingImageProperties;
488 #if ENABLE(CSS_SHADERS)
489         bool hasPendingShaders;
490 #endif
491 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
492         PendingSVGDocumentMap pendingSVGDocuments;
493 #endif
494         CSSValue* lineHeightValue;
495         bool fontDirty;
496
497         bool hasUAAppearance;
498         BorderData borderData;
499         FillLayer backgroundData;
500         Color backgroundColor;
501     };
502
503     static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
504
505     PassRefPtr<StyleImage> styleImage(CSSPropertyID, CSSValue*);
506     PassRefPtr<StyleImage> cachedOrPendingFromValue(CSSPropertyID, CSSImageValue*);
507     PassRefPtr<StyleImage> generatedOrPendingFromValue(CSSPropertyID, CSSImageGeneratorValue*);
508 #if ENABLE(CSS_IMAGE_SET)
509     PassRefPtr<StyleImage> setOrPendingFromValue(CSSPropertyID, CSSImageSetValue*);
510 #endif
511     PassRefPtr<StyleImage> cursorOrPendingFromValue(CSSPropertyID, CSSCursorImageValue*);
512
513     bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle; }
514     bool applyPropertyToVisitedLinkStyle() const { return m_state.applyPropertyToVisitedLinkStyle; }
515
516     static Length convertToIntLength(CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, double multiplier = 1);
517     static Length convertToFloatLength(CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, double multiplier = 1);
518
519     CSSToStyleMap* styleMap() { return &m_styleMap; }
520     InspectorCSSOMWrappers& inspectorCSSOMWrappers() { return m_inspectorCSSOMWrappers; }
521
522     void reportMemoryUsage(MemoryObjectInfo*) const;
523     
524 private:
525     static RenderStyle* s_styleNotYetAvailable;
526
527     void cacheBorderAndBackground();
528
529 private:
530     bool canShareStyleWithControl(StyledElement*) const;
531
532     void applyProperty(CSSPropertyID, CSSValue*);
533
534 #if ENABLE(SVG)
535     void applySVGProperty(CSSPropertyID, CSSValue*);
536 #endif
537
538     PassRefPtr<StyleImage> loadPendingImage(StylePendingImage*);
539     void loadPendingImages();
540
541     static unsigned computeMatchedPropertiesHash(const MatchedProperties*, unsigned size);
542     struct MatchedPropertiesCacheItem {
543         void reportMemoryUsage(MemoryObjectInfo*) const;
544         Vector<MatchedProperties> matchedProperties;
545         MatchRanges ranges;
546         RefPtr<RenderStyle> renderStyle;
547         RefPtr<RenderStyle> parentRenderStyle;
548     };
549     const MatchedPropertiesCacheItem* findFromMatchedPropertiesCache(unsigned hash, const MatchResult&);
550     void addToMatchedPropertiesCache(const RenderStyle*, const RenderStyle* parentStyle, unsigned hash, const MatchResult&);
551
552     // Every N additions to the matched declaration cache trigger a sweep where entries holding
553     // the last reference to a style declaration are garbage collected.
554     void sweepMatchedPropertiesCache(Timer<StyleResolver>*);
555
556     bool classNamesAffectedByRules(const SpaceSplitString&) const;
557     bool sharingCandidateHasIdenticalStyleAffectingAttributes(StyledElement*) const;
558
559     unsigned m_matchedPropertiesCacheAdditionsSinceLastSweep;
560
561     typedef HashMap<unsigned, MatchedPropertiesCacheItem> MatchedPropertiesCache;
562     MatchedPropertiesCache m_matchedPropertiesCache;
563
564     Timer<StyleResolver> m_matchedPropertiesCacheSweepTimer;
565
566     OwnPtr<MediaQueryEvaluator> m_medium;
567     RefPtr<RenderStyle> m_rootDefaultStyle;
568
569     Document* m_document;
570     // FIXME: Make SelectorChecker an on-stack object and
571     // move selectorChecker.mode() to State.
572     // selectorChecker.stringParsing() can be replaced with
573     // !document.inQuirksMode().
574     SelectorChecker m_selectorChecker;
575     SelectorFilter m_selectorFilter;
576
577     bool m_matchAuthorAndUserStyles;
578
579     RefPtr<CSSFontSelector> m_fontSelector;
580     Vector<OwnPtr<MediaQueryResult> > m_viewportDependentMediaQueryResults;
581
582 #if ENABLE(CSS_DEVICE_ADAPTATION)
583     RefPtr<ViewportStyleResolver> m_viewportStyleResolver;
584 #endif
585
586     const StyleBuilder& m_styleBuilder;
587
588     OwnPtr<StyleScopeResolver> m_scopeResolver;
589     CSSToStyleMap m_styleMap;
590     InspectorCSSOMWrappers m_inspectorCSSOMWrappers;
591
592     State m_state;
593
594     friend class StyleBuilder;
595     friend bool operator==(const MatchedProperties&, const MatchedProperties&);
596     friend bool operator!=(const MatchedProperties&, const MatchedProperties&);
597     friend bool operator==(const MatchRanges&, const MatchRanges&);
598     friend bool operator!=(const MatchRanges&, const MatchRanges&);
599 };
600
601 inline bool StyleResolver::hasSelectorForAttribute(const AtomicString &attributeName) const
602 {
603     ASSERT(!attributeName.isEmpty());
604     return m_ruleSets.features().attrsInRules.contains(attributeName.impl());
605 }
606
607 inline bool StyleResolver::hasSelectorForClass(const AtomicString& classValue) const
608 {
609     ASSERT(!classValue.isEmpty());
610     return m_ruleSets.features().classesInRules.contains(classValue.impl());
611 }
612
613 inline bool StyleResolver::hasSelectorForId(const AtomicString& idValue) const
614 {
615     ASSERT(!idValue.isEmpty());
616     return m_ruleSets.features().idsInRules.contains(idValue.impl());
617 }
618
619 } // namespace WebCore
620
621 #endif // StyleResolver_h