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