2011-04-05 Luke Macpherson <macpherson@chromium.org>
[WebKit-https.git] / Source / WebCore / css / CSSStyleSelector.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 CSSStyleSelector_h
23 #define CSSStyleSelector_h
24
25 #include "CSSFontSelector.h"
26 #include "CSSRule.h"
27 #include "LinkHash.h"
28 #include "MediaQueryExp.h"
29 #include "RenderStyle.h"
30 #include <wtf/BloomFilter.h>
31 #include <wtf/HashMap.h>
32 #include <wtf/HashSet.h>
33 #include <wtf/RefPtr.h>
34 #include <wtf/Vector.h>
35 #include <wtf/text/StringHash.h>
36
37 namespace WebCore {
38
39 class CSSMutableStyleDeclaration;
40 class CSSPageRule;
41 class CSSPrimitiveValue;
42 class CSSProperty;
43 class CSSFontFace;
44 class CSSFontFaceRule;
45 class CSSImageValue;
46 class CSSRuleList;
47 class CSSSelector;
48 class CSSStyleApplyProperty;
49 class CSSStyleRule;
50 class CSSStyleSheet;
51 class CSSValue;
52 class ContainerNode;
53 class DataGridColumn;
54 class Document;
55 class Element;
56 class Frame;
57 class FrameView;
58 class KURL;
59 class KeyframeList;
60 class KeyframeValue;
61 class MediaQueryEvaluator;
62 class Node;
63 class RuleData;
64 class RuleSet;
65 class Settings;
66 class StyleImage;
67 class StyleSheet;
68 class StyleSheetList;
69 class StyledElement;
70 class WebKitCSSKeyframeRule;
71 class WebKitCSSKeyframesRule;
72
73 class MediaQueryResult {
74     WTF_MAKE_NONCOPYABLE(MediaQueryResult); WTF_MAKE_FAST_ALLOCATED;
75 public:
76     MediaQueryResult(const MediaQueryExp& expr, bool result)
77         : m_expression(expr)
78         , m_result(result)
79     {
80     }
81
82     MediaQueryExp m_expression;
83     bool m_result;
84 };
85
86     // This class selects a RenderStyle for a given element based on a collection of stylesheets.
87     class CSSStyleSelector {
88         WTF_MAKE_NONCOPYABLE(CSSStyleSelector); WTF_MAKE_FAST_ALLOCATED;
89     public:
90         CSSStyleSelector(Document*, StyleSheetList* authorSheets, CSSStyleSheet* mappedElementSheet,
91                          CSSStyleSheet* pageUserSheet, const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets,
92                          bool strictParsing, bool matchAuthorAndUserStyles);
93         ~CSSStyleSelector();
94         
95         // Using these during tree walk will allow style selector to optimize child and descendant selector lookups.
96         void pushParent(Element* parent);
97         void popParent(Element* parent);
98
99
100         PassRefPtr<RenderStyle> styleForElement(Element* e, RenderStyle* parentStyle = 0, bool allowSharing = true, bool resolveForRootDefault = false, bool matchVisitedPseudoClass = false);
101         
102         void keyframeStylesForAnimation(Element*, const RenderStyle*, KeyframeList& list);
103
104         PassRefPtr<RenderStyle> pseudoStyleForElement(PseudoId pseudo, Element* e, RenderStyle* parentStyle = 0, bool matchVisitedPseudoClass = false);
105
106         PassRefPtr<RenderStyle> styleForPage(int pageIndex);
107
108         static PassRefPtr<RenderStyle> styleForDocument(Document*);
109
110 #if ENABLE(DATAGRID)
111         // Datagrid style computation (uses unique pseudo elements and structures)
112         PassRefPtr<RenderStyle> pseudoStyleForDataGridColumn(DataGridColumn*, RenderStyle* parentStyle);
113         PassRefPtr<RenderStyle> pseudoStyleForDataGridColumnHeader(DataGridColumn*, RenderStyle* parentStyle);
114 #endif
115
116         RenderStyle* style() const { return m_style.get(); }
117         RenderStyle* parentStyle() const { return m_parentStyle; }
118         Element* element() const { return m_element; }
119
120     private:
121         void initForStyleResolve(Element*, RenderStyle* parentStyle = 0, PseudoId = NOPSEUDO);
122         void initElement(Element*);
123         RenderStyle* locateSharedStyle();
124         bool matchesSiblingRules();
125         Node* locateCousinList(Element* parent, unsigned& visitedNodeCount) const;
126         Node* findSiblingForStyleSharing(Node*, unsigned& count) const;
127         bool canShareStyleWithElement(Node*) const;
128         
129         void pushParentStackFrame(Element* parent);
130         void popParentStackFrame();
131
132         PassRefPtr<RenderStyle> styleForKeyframe(const RenderStyle*, const WebKitCSSKeyframeRule*, KeyframeValue&);
133
134     public:
135         // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
136         PassRefPtr<CSSRuleList> styleRulesForElement(Element*, bool authorOnly, bool includeEmptyRules = false, CSSRuleFilter filter = AllCSSRules);
137         PassRefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, PseudoId, bool authorOnly, bool includeEmptyRules = false, CSSRuleFilter filter = AllCSSRules);
138
139         // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
140         // the correct font size scaled relative to the user's default (medium).
141         static float fontSizeForKeyword(Document*, int keyword, bool shouldUseFixedDefaultSize);
142
143         // Given a font size in pixel, this function will return legacy font size between 1 and 7.
144         static int legacyFontSize(Document*, int pixelFontSize, bool shouldUseFixedDefaultSize);
145
146     private:
147
148         // When the CSS keyword "larger" is used, this function will attempt to match within the keyword
149         // table, and failing that, will simply multiply by 1.2.
150         float largerFontSize(float size, bool quirksMode) const;
151
152         // Like the previous function, but for the keyword "smaller".
153         float smallerFontSize(float size, bool quirksMode) const;
154
155     public:
156         void setStyle(PassRefPtr<RenderStyle> s) { m_style = s; } // Used by the document when setting up its root style.
157
158         void applyPropertyToStyle(int id, CSSValue*, RenderStyle*);
159
160     private:
161         void setFontSize(FontDescription&, float size);
162         static float getComputedSizeFromSpecifiedSize(Document*, RenderStyle*, bool isAbsoluteSize, float specifiedSize, bool useSVGZoomRules);
163     public:
164         Color getColorFromPrimitiveValue(CSSPrimitiveValue*) const;
165
166         bool hasSelectorForAttribute(const AtomicString&) const;
167  
168         CSSFontSelector* fontSelector() const { return m_fontSelector.get(); }
169
170         void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
171
172         bool affectedByViewportChange() const;
173
174         void allVisitedStateChanged() { m_checker.allVisitedStateChanged(); }
175         void visitedStateChanged(LinkHash visitedHash) { m_checker.visitedStateChanged(visitedHash); }
176
177         void addKeyframeStyle(PassRefPtr<WebKitCSSKeyframesRule> rule);
178         void addPageStyle(PassRefPtr<CSSPageRule>);
179
180         bool usesSiblingRules() const { return m_features.siblingRules; }
181         bool usesFirstLineRules() const { return m_features.usesFirstLineRules; }
182         bool usesBeforeAfterRules() const { return m_features.usesBeforeAfterRules; }
183         bool usesLinkRules() const { return m_features.usesLinkRules; }
184
185         static bool createTransformOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, TransformOperations& outOperations);
186
187         struct Features {
188             Features();
189             ~Features();
190             HashSet<AtomicStringImpl*> idsInRules;
191             OwnPtr<RuleSet> siblingRules;
192             bool usesFirstLineRules;
193             bool usesBeforeAfterRules;
194             bool usesLinkRules;
195         };
196
197     private:
198         enum SelectorMatch { SelectorMatches, SelectorFailsLocally, SelectorFailsCompletely };
199
200         // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
201         void checkForGenericFamilyChange(RenderStyle*, RenderStyle* parentStyle);
202         void checkForZoomChange(RenderStyle*, RenderStyle* parentStyle);
203         void checkForTextSizeAdjust();
204
205         void adjustRenderStyle(RenderStyle* styleToAdjust, RenderStyle* parentStyle, Element*);
206
207         void addMatchedRule(const RuleData* rule) { m_matchedRules.append(rule); }
208         void addMatchedDeclaration(CSSMutableStyleDeclaration* decl);
209
210         void matchRules(RuleSet*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);
211         void matchRulesForList(const Vector<RuleData>*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);
212         bool fastRejectSelector(const RuleData&) const;
213         void sortMatchedRules();
214         
215         bool checkSelector(const RuleData&);
216
217         template <bool firstPass>
218         void applyDeclarations(bool important, int startIndex, int endIndex);
219
220         void matchPageRules(RuleSet*, bool isLeftPage, bool isFirstPage, const String& pageName);
221         void matchPageRulesForList(const Vector<RuleData>*, bool isLeftPage, bool isFirstPage, const String& pageName);
222         bool isLeftPage(int pageIndex) const;
223         bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
224         bool isFirstPage(int pageIndex) const;
225         String pageName(int pageIndex) const;
226         
227         OwnPtr<RuleSet> m_authorStyle;
228         OwnPtr<RuleSet> m_userStyle;
229
230         Features m_features;
231
232         struct ParentStackFrame {
233             ParentStackFrame() {}
234             ParentStackFrame(Element* element) : element(element) {}
235             Element* element;
236             Vector<unsigned, 4> identifierHashes;
237         };
238         Vector<ParentStackFrame> m_parentStack;
239         
240         // With 100 unique strings in the filter, 2^12 slot table has false positive rate of ~0.2%.
241         static const unsigned bloomFilterKeyBits = 12;
242         OwnPtr<BloomFilter<bloomFilterKeyBits> > m_ancestorIdentifierFilter;
243
244         bool m_hasUAAppearance;
245         BorderData m_borderData;
246         FillLayer m_backgroundData;
247         Color m_backgroundColor;
248
249         typedef HashMap<AtomicStringImpl*, RefPtr<WebKitCSSKeyframesRule> > KeyframesRuleMap;
250         KeyframesRuleMap m_keyframesRuleMap;
251
252     public:
253         static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
254
255         class SelectorChecker {
256             WTF_MAKE_NONCOPYABLE(SelectorChecker);
257         public:
258             SelectorChecker(Document*, bool strictParsing);
259
260             bool checkSelector(CSSSelector*, Element*) const;
261             SelectorMatch checkSelector(CSSSelector*, Element*, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, bool encounteredLink, RenderStyle* = 0, RenderStyle* elementParentStyle = 0) const;
262             bool checkOneSelector(CSSSelector*, Element*, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, bool encounteredLink, RenderStyle*, RenderStyle* elementParentStyle) const;
263             bool checkScrollbarPseudoClass(CSSSelector*, PseudoId& dynamicPseudo) const;
264             static bool fastCheckSelector(const CSSSelector*, const Element*);
265
266             EInsideLink determineLinkState(Element* element) const;
267             EInsideLink determineLinkStateSlowCase(Element* element) const;
268             void allVisitedStateChanged();
269             void visitedStateChanged(LinkHash visitedHash);
270
271             Document* m_document;
272             bool m_strictParsing;
273             bool m_collectRulesOnly;
274             bool m_sameOriginOnly;
275             PseudoId m_pseudoStyle;
276             bool m_documentIsHTML;
277             mutable bool m_matchVisitedPseudoClass;
278             mutable HashSet<LinkHash, LinkHashHash> m_linksCheckedForVisitedState;
279         };
280
281     private:
282         static RenderStyle* s_styleNotYetAvailable;
283
284         void matchUARules(int& firstUARule, int& lastUARule);
285         void updateFont();
286         void cacheBorderAndBackground();
287
288         void mapFillAttachment(CSSPropertyID, FillLayer*, CSSValue*);
289         void mapFillClip(CSSPropertyID, FillLayer*, CSSValue*);
290         void mapFillComposite(CSSPropertyID, FillLayer*, CSSValue*);
291         void mapFillOrigin(CSSPropertyID, FillLayer*, CSSValue*);
292         void mapFillImage(CSSPropertyID, FillLayer*, CSSValue*);
293         void mapFillRepeatX(CSSPropertyID, FillLayer*, CSSValue*);
294         void mapFillRepeatY(CSSPropertyID, FillLayer*, CSSValue*);
295         void mapFillSize(CSSPropertyID, FillLayer*, CSSValue*);
296         void mapFillXPosition(CSSPropertyID, FillLayer*, CSSValue*);
297         void mapFillYPosition(CSSPropertyID, FillLayer*, CSSValue*);
298
299         void mapAnimationDelay(Animation*, CSSValue*);
300         void mapAnimationDirection(Animation*, CSSValue*);
301         void mapAnimationDuration(Animation*, CSSValue*);
302         void mapAnimationFillMode(Animation*, CSSValue*);
303         void mapAnimationIterationCount(Animation*, CSSValue*);
304         void mapAnimationName(Animation*, CSSValue*);
305         void mapAnimationPlayState(Animation*, CSSValue*);
306         void mapAnimationProperty(Animation*, CSSValue*);
307         void mapAnimationTimingFunction(Animation*, CSSValue*);
308
309         void mapNinePieceImage(CSSPropertyID, CSSValue*, NinePieceImage&);
310
311         void applyProperty(int id, CSSValue*);
312         void applyPageSizeProperty(CSSValue*);
313         bool pageSizeFromName(CSSPrimitiveValue*, CSSPrimitiveValue*, Length& width, Length& height);
314         Length mmLength(double mm) const;
315         Length inchLength(double inch) const;
316 #if ENABLE(SVG)
317         void applySVGProperty(int id, CSSValue*);
318 #endif
319
320         void loadPendingImages();
321         
322         StyleImage* styleImage(CSSPropertyID, CSSValue* value);
323         StyleImage* cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue* value);
324
325         // We collect the set of decls that match in |m_matchedDecls|.  We then walk the
326         // set of matched decls four times, once for those properties that others depend on (like font-size),
327         // and then a second time for all the remaining properties.  We then do the same two passes
328         // for any !important rules.
329         Vector<CSSMutableStyleDeclaration*, 64> m_matchedDecls;
330
331         // A buffer used to hold the set of matched rules for an element, and a temporary buffer used for
332         // merge sorting.
333         Vector<const RuleData*, 32> m_matchedRules;
334
335         RefPtr<CSSRuleList> m_ruleList;
336         
337         HashSet<int> m_pendingImageProperties; // Hash of CSSPropertyIDs
338
339         OwnPtr<MediaQueryEvaluator> m_medium;
340         RefPtr<RenderStyle> m_rootDefaultStyle;
341
342         PseudoId m_dynamicPseudo;
343
344         SelectorChecker m_checker;
345
346         RefPtr<RenderStyle> m_style;
347         RenderStyle* m_parentStyle;
348         RenderStyle* m_rootElementStyle;
349         Element* m_element;
350         StyledElement* m_styledElement;
351         EInsideLink m_elementLinkState;
352         ContainerNode* m_parentNode;
353         CSSValue* m_lineHeightValue;
354         bool m_fontDirty;
355         bool m_matchAuthorAndUserStyles;
356         
357         RefPtr<CSSFontSelector> m_fontSelector;
358         HashSet<AtomicStringImpl*> m_selectorAttrs;
359         Vector<CSSMutableStyleDeclaration*> m_additionalAttributeStyleDecls;
360         Vector<MediaQueryResult*> m_viewportDependentMediaQueryResults;
361
362         const CSSStyleApplyProperty& m_applyProperty;
363     };
364
365 } // namespace WebCore
366
367 #endif // CSSStyleSelector_h