2010-11-09 Yuzo Fujishima <yuzo@google.com>
[WebKit-https.git] / WebCore / css / CSSStyleSelector.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
4  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
5  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
6  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
7  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
8  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  */
25
26 #include "config.h"
27 #include "CSSStyleSelector.h"
28
29 #include "Attribute.h"
30 #include "CSSBorderImageValue.h"
31 #include "CSSCursorImageValue.h"
32 #include "CSSFontFaceRule.h"
33 #include "CSSImportRule.h"
34 #include "CSSMediaRule.h"
35 #include "CSSPageRule.h"
36 #include "CSSParser.h"
37 #include "CSSPrimitiveValueMappings.h"
38 #include "CSSPropertyNames.h"
39 #include "CSSReflectValue.h"
40 #include "CSSRuleList.h"
41 #include "CSSSelector.h"
42 #include "CSSSelectorList.h"
43 #include "CSSStyleRule.h"
44 #include "CSSStyleSheet.h"
45 #include "CSSTimingFunctionValue.h"
46 #include "CSSValueList.h"
47 #include "CSSVariableDependentValue.h"
48 #include "CSSVariablesDeclaration.h"
49 #include "CSSVariablesRule.h"
50 #include "CachedImage.h"
51 #include "Counter.h"
52 #include "FocusController.h"
53 #include "FontFamilyValue.h"
54 #include "FontValue.h"
55 #include "Frame.h"
56 #include "FrameView.h"
57 #include "HTMLDocument.h"
58 #include "HTMLElement.h"
59 #include "HTMLInputElement.h"
60 #include "HTMLNames.h"
61 #include "HTMLTextAreaElement.h"
62 #include "KeyframeList.h"
63 #include "LinkHash.h"
64 #include "Matrix3DTransformOperation.h"
65 #include "MatrixTransformOperation.h"
66 #include "MediaList.h"
67 #include "MediaQueryEvaluator.h"
68 #include "NodeRenderStyle.h"
69 #include "Page.h"
70 #include "PageGroup.h"
71 #include "Pair.h"
72 #include "PerspectiveTransformOperation.h"
73 #include "Rect.h"
74 #include "RenderScrollbar.h"
75 #include "RenderScrollbarTheme.h"
76 #include "RenderStyleConstants.h"
77 #include "RenderTheme.h"
78 #include "RotateTransformOperation.h"
79 #include "ScaleTransformOperation.h"
80 #include "SelectionController.h"
81 #include "Settings.h"
82 #include "ShadowValue.h"
83 #include "SkewTransformOperation.h"
84 #include "StyleCachedImage.h"
85 #include "StylePendingImage.h"
86 #include "StyleGeneratedImage.h"
87 #include "StyleSheetList.h"
88 #include "Text.h"
89 #include "TransformationMatrix.h"
90 #include "TranslateTransformOperation.h"
91 #include "UserAgentStyleSheets.h"
92 #include "WebKitCSSKeyframeRule.h"
93 #include "WebKitCSSKeyframesRule.h"
94 #include "WebKitCSSTransformValue.h"
95 #include "XMLNames.h"
96 #include "loader.h"
97 #include <wtf/StdLibExtras.h>
98 #include <wtf/Vector.h>
99
100 #if USE(PLATFORM_STRATEGIES)
101 #include "PlatformStrategies.h"
102 #include "VisitedLinkStrategy.h"
103 #endif
104
105 #if ENABLE(DASHBOARD_SUPPORT)
106 #include "DashboardRegion.h"
107 #endif
108
109 #if ENABLE(SVG)
110 #include "XLinkNames.h"
111 #include "SVGNames.h"
112 #endif
113
114 #if ENABLE(WML)
115 #include "WMLNames.h"
116 #endif
117
118 #if PLATFORM(QT)
119 #include <qwebhistoryinterface.h>
120 #endif
121
122 using namespace std;
123
124 namespace WebCore {
125
126 using namespace HTMLNames;
127
128 #define HANDLE_INHERIT(prop, Prop) \
129 if (isInherit) { \
130     m_style->set##Prop(m_parentStyle->prop()); \
131     return; \
132 }
133
134 #define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
135 HANDLE_INHERIT(prop, Prop) \
136 if (isInitial) { \
137     m_style->set##Prop(RenderStyle::initial##Prop()); \
138     return; \
139 }
140
141 #define HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(prop, Prop, Value) \
142 HANDLE_INHERIT(prop, Prop) \
143 if (isInitial) { \
144     m_style->set##Prop(RenderStyle::initial##Value());\
145     return;\
146 }
147
148 #define HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(prop, Prop) \
149 HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
150 if (primitiveValue) \
151     m_style->set##Prop(*primitiveValue);
152
153 #define HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE_WITH_VALUE(prop, Prop, Value) \
154 HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(prop, Prop, Value) \
155 if (primitiveValue) \
156     m_style->set##Prop(*primitiveValue);
157
158 #define HANDLE_FILL_LAYER_INHERIT_AND_INITIAL(layerType, LayerType, prop, Prop) \
159 if (isInherit) { \
160     FillLayer* currChild = m_style->access##LayerType##Layers(); \
161     FillLayer* prevChild = 0; \
162     const FillLayer* currParent = m_parentStyle->layerType##Layers(); \
163     while (currParent && currParent->is##Prop##Set()) { \
164         if (!currChild) { \
165             /* Need to make a new layer.*/ \
166             currChild = new FillLayer(LayerType##FillLayer); \
167             prevChild->setNext(currChild); \
168         } \
169         currChild->set##Prop(currParent->prop()); \
170         prevChild = currChild; \
171         currChild = prevChild->next(); \
172         currParent = currParent->next(); \
173     } \
174     \
175     while (currChild) { \
176         /* Reset any remaining layers to not have the property set. */ \
177         currChild->clear##Prop(); \
178         currChild = currChild->next(); \
179     } \
180 } else if (isInitial) { \
181     FillLayer* currChild = m_style->access##LayerType##Layers(); \
182     currChild->set##Prop(FillLayer::initialFill##Prop(LayerType##FillLayer)); \
183     for (currChild = currChild->next(); currChild; currChild = currChild->next()) \
184         currChild->clear##Prop(); \
185 }
186
187 #define HANDLE_FILL_LAYER_VALUE(layerType, LayerType, prop, Prop, value) { \
188 HANDLE_FILL_LAYER_INHERIT_AND_INITIAL(layerType, LayerType, prop, Prop) \
189 if (isInherit || isInitial) \
190     return; \
191 FillLayer* currChild = m_style->access##LayerType##Layers(); \
192 FillLayer* prevChild = 0; \
193 if (value->isValueList()) { \
194     /* Walk each value and put it into a layer, creating new layers as needed. */ \
195     CSSValueList* valueList = static_cast<CSSValueList*>(value); \
196     for (unsigned int i = 0; i < valueList->length(); i++) { \
197         if (!currChild) { \
198             /* Need to make a new layer to hold this value */ \
199             currChild = new FillLayer(LayerType##FillLayer); \
200             prevChild->setNext(currChild); \
201         } \
202         mapFill##Prop(property, currChild, valueList->itemWithoutBoundsCheck(i)); \
203         prevChild = currChild; \
204         currChild = currChild->next(); \
205     } \
206 } else { \
207     mapFill##Prop(property, currChild, value); \
208     currChild = currChild->next(); \
209 } \
210 while (currChild) { \
211     /* Reset all remaining layers to not have the property set. */ \
212     currChild->clear##Prop(); \
213     currChild = currChild->next(); \
214 } }
215
216 #define HANDLE_BACKGROUND_INHERIT_AND_INITIAL(prop, Prop) \
217 HANDLE_FILL_LAYER_INHERIT_AND_INITIAL(background, Background, prop, Prop)
218
219 #define HANDLE_BACKGROUND_VALUE(prop, Prop, value) \
220 HANDLE_FILL_LAYER_VALUE(background, Background, prop, Prop, value)
221
222 #define HANDLE_MASK_INHERIT_AND_INITIAL(prop, Prop) \
223 HANDLE_FILL_LAYER_INHERIT_AND_INITIAL(mask, Mask, prop, Prop)
224
225 #define HANDLE_MASK_VALUE(prop, Prop, value) \
226 HANDLE_FILL_LAYER_VALUE(mask, Mask, prop, Prop, value)
227
228 #define HANDLE_ANIMATION_INHERIT_AND_INITIAL(prop, Prop) \
229 if (isInherit) { \
230     AnimationList* list = m_style->accessAnimations(); \
231     const AnimationList* parentList = m_parentStyle->animations(); \
232     size_t i = 0, parentSize = parentList ? parentList->size() : 0; \
233     for ( ; i < parentSize && parentList->animation(i)->is##Prop##Set(); ++i) { \
234         if (list->size() <= i) \
235             list->append(Animation::create()); \
236         list->animation(i)->set##Prop(parentList->animation(i)->prop()); \
237     } \
238     \
239     /* Reset any remaining animations to not have the property set. */ \
240     for ( ; i < list->size(); ++i) \
241         list->animation(i)->clear##Prop(); \
242 } else if (isInitial) { \
243     AnimationList* list = m_style->accessAnimations(); \
244     if (list->isEmpty()) \
245         list->append(Animation::create()); \
246     list->animation(0)->set##Prop(Animation::initialAnimation##Prop()); \
247     for (size_t i = 1; i < list->size(); ++i) \
248         list->animation(0)->clear##Prop(); \
249 }
250
251 #define HANDLE_ANIMATION_VALUE(prop, Prop, value) { \
252 HANDLE_ANIMATION_INHERIT_AND_INITIAL(prop, Prop) \
253 if (isInherit || isInitial) \
254     return; \
255 AnimationList* list = m_style->accessAnimations(); \
256 size_t childIndex = 0; \
257 if (value->isValueList()) { \
258     /* Walk each value and put it into an animation, creating new animations as needed. */ \
259     CSSValueList* valueList = static_cast<CSSValueList*>(value); \
260     for (unsigned int i = 0; i < valueList->length(); i++) { \
261         if (childIndex <= list->size()) \
262             list->append(Animation::create()); \
263         mapAnimation##Prop(list->animation(childIndex), valueList->itemWithoutBoundsCheck(i)); \
264         ++childIndex; \
265     } \
266 } else { \
267     if (list->isEmpty()) \
268         list->append(Animation::create()); \
269     mapAnimation##Prop(list->animation(childIndex), value); \
270     childIndex = 1; \
271 } \
272 for ( ; childIndex < list->size(); ++childIndex) { \
273     /* Reset all remaining animations to not have the property set. */ \
274     list->animation(childIndex)->clear##Prop(); \
275 } \
276 }
277
278 #define HANDLE_TRANSITION_INHERIT_AND_INITIAL(prop, Prop) \
279 if (isInherit) { \
280     AnimationList* list = m_style->accessTransitions(); \
281     const AnimationList* parentList = m_parentStyle->transitions(); \
282     size_t i = 0, parentSize = parentList ? parentList->size() : 0; \
283     for ( ; i < parentSize && parentList->animation(i)->is##Prop##Set(); ++i) { \
284         if (list->size() <= i) \
285             list->append(Animation::create()); \
286         list->animation(i)->set##Prop(parentList->animation(i)->prop()); \
287     } \
288     \
289     /* Reset any remaining transitions to not have the property set. */ \
290     for ( ; i < list->size(); ++i) \
291         list->animation(i)->clear##Prop(); \
292 } else if (isInitial) { \
293     AnimationList* list = m_style->accessTransitions(); \
294     if (list->isEmpty()) \
295         list->append(Animation::create()); \
296     list->animation(0)->set##Prop(Animation::initialAnimation##Prop()); \
297     for (size_t i = 1; i < list->size(); ++i) \
298         list->animation(0)->clear##Prop(); \
299 }
300
301 #define HANDLE_TRANSITION_VALUE(prop, Prop, value) { \
302 HANDLE_TRANSITION_INHERIT_AND_INITIAL(prop, Prop) \
303 if (isInherit || isInitial) \
304     return; \
305 AnimationList* list = m_style->accessTransitions(); \
306 size_t childIndex = 0; \
307 if (value->isValueList()) { \
308     /* Walk each value and put it into a transition, creating new animations as needed. */ \
309     CSSValueList* valueList = static_cast<CSSValueList*>(value); \
310     for (unsigned int i = 0; i < valueList->length(); i++) { \
311         if (childIndex <= list->size()) \
312             list->append(Animation::create()); \
313         mapAnimation##Prop(list->animation(childIndex), valueList->itemWithoutBoundsCheck(i)); \
314         ++childIndex; \
315     } \
316 } else { \
317     if (list->isEmpty()) \
318         list->append(Animation::create()); \
319     mapAnimation##Prop(list->animation(childIndex), value); \
320     childIndex = 1; \
321 } \
322 for ( ; childIndex < list->size(); ++childIndex) { \
323     /* Reset all remaining transitions to not have the property set. */ \
324     list->animation(childIndex)->clear##Prop(); \
325 } \
326 }
327
328 #define HANDLE_INHERIT_COND(propID, prop, Prop) \
329 if (id == propID) { \
330     m_style->set##Prop(m_parentStyle->prop()); \
331     return; \
332 }
333     
334 #define HANDLE_INHERIT_COND_WITH_BACKUP(propID, prop, propAlt, Prop) \
335 if (id == propID) { \
336     if (m_parentStyle->prop().isValid()) \
337         m_style->set##Prop(m_parentStyle->prop()); \
338     else \
339         m_style->set##Prop(m_parentStyle->propAlt()); \
340     return; \
341 }
342
343 #define HANDLE_INITIAL_COND(propID, Prop) \
344 if (id == propID) { \
345     m_style->set##Prop(RenderStyle::initial##Prop()); \
346     return; \
347 }
348
349 #define HANDLE_INITIAL_COND_WITH_VALUE(propID, Prop, Value) \
350 if (id == propID) { \
351     m_style->set##Prop(RenderStyle::initial##Value()); \
352     return; \
353 }
354
355 class CSSRuleSet : public Noncopyable {
356 public:
357     CSSRuleSet();
358     ~CSSRuleSet();
359     
360     typedef HashMap<AtomicStringImpl*, CSSRuleDataList*> AtomRuleMap;
361     
362     void addRulesFromSheet(CSSStyleSheet*, const MediaQueryEvaluator&, CSSStyleSelector* = 0);
363
364     void addStyleRule(StyleBase* item);
365     void addRule(CSSStyleRule* rule, CSSSelector* sel);
366     void addPageRule(CSSStyleRule* rule, CSSSelector* sel);
367     void addToRuleSet(AtomicStringImpl* key, AtomRuleMap& map,
368                       CSSStyleRule* rule, CSSSelector* sel);
369     
370     CSSRuleDataList* getIDRules(AtomicStringImpl* key) { return m_idRules.get(key); }
371     CSSRuleDataList* getClassRules(AtomicStringImpl* key) { return m_classRules.get(key); }
372     CSSRuleDataList* getTagRules(AtomicStringImpl* key) { return m_tagRules.get(key); }
373     CSSRuleDataList* getUniversalRules() { return m_universalRules.get(); }
374     CSSRuleDataList* getPageRules() { return m_pageRules.get(); }
375     
376 public:
377     AtomRuleMap m_idRules;
378     AtomRuleMap m_classRules;
379     AtomRuleMap m_tagRules;
380     OwnPtr<CSSRuleDataList> m_universalRules;
381     OwnPtr<CSSRuleDataList> m_pageRules;
382     unsigned m_ruleCount;
383     unsigned m_pageRuleCount;
384 };
385
386 static CSSRuleSet* defaultStyle;
387 static CSSRuleSet* defaultQuirksStyle;
388 static CSSRuleSet* defaultPrintStyle;
389 static CSSRuleSet* defaultViewSourceStyle;
390 static CSSStyleSheet* simpleDefaultStyleSheet;
391
392 RenderStyle* CSSStyleSelector::s_styleNotYetAvailable;
393
394 static void loadFullDefaultStyle();
395 static void loadSimpleDefaultStyle();
396 // FIXME: It would be nice to use some mechanism that guarantees this is in sync with the real UA stylesheet.
397 static const char* simpleUserAgentStyleSheet = "html,body,div{display:block}body{margin:8px}div:focus,span:focus{outline:auto 5px -webkit-focus-ring-color}a:-webkit-any-link{color:-webkit-link;text-decoration:underline}a:-webkit-any-link:active{color:-webkit-activelink}";
398
399 static bool elementCanUseSimpleDefaultStyle(Element* e)
400 {
401     return e->hasTagName(htmlTag) || e->hasTagName(bodyTag) || e->hasTagName(divTag) || e->hasTagName(spanTag) || e->hasTagName(brTag) || e->hasTagName(aTag);
402 }
403
404 static const MediaQueryEvaluator& screenEval()
405 {
406     DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticScreenEval, ("screen"));
407     return staticScreenEval;
408 }
409
410 static const MediaQueryEvaluator& printEval()
411 {
412     DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticPrintEval, ("print"));
413     return staticPrintEval;
414 }
415
416 CSSStyleSelector::CSSStyleSelector(Document* document, StyleSheetList* styleSheets, CSSStyleSheet* mappedElementSheet,
417                                    CSSStyleSheet* pageUserSheet, const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets,
418                                    bool strictParsing, bool matchAuthorAndUserStyles)
419     : m_backgroundData(BackgroundFillLayer)
420     , m_checker(document, strictParsing)
421     , m_element(0)
422     , m_styledElement(0)
423     , m_elementLinkState(NotInsideLink)
424     , m_fontSelector(CSSFontSelector::create(document))
425 {
426     m_matchAuthorAndUserStyles = matchAuthorAndUserStyles;
427     
428     Element* root = document->documentElement();
429
430     if (!defaultStyle) {
431         if (!root || elementCanUseSimpleDefaultStyle(root))
432             loadSimpleDefaultStyle();
433         else
434             loadFullDefaultStyle();
435     }
436
437     // construct document root element default style. this is needed
438     // to evaluate media queries that contain relative constraints, like "screen and (max-width: 10em)"
439     // This is here instead of constructor, because when constructor is run,
440     // document doesn't have documentElement
441     // NOTE: this assumes that element that gets passed to styleForElement -call
442     // is always from the document that owns the style selector
443     FrameView* view = document->view();
444     if (view)
445         m_medium = adoptPtr(new MediaQueryEvaluator(view->mediaType()));
446     else
447         m_medium = adoptPtr(new MediaQueryEvaluator("all"));
448
449     if (root)
450         m_rootDefaultStyle = styleForElement(root, 0, false, true); // don't ref, because the RenderStyle is allocated from global heap
451
452     if (m_rootDefaultStyle && view)
453         m_medium = adoptPtr(new MediaQueryEvaluator(view->mediaType(), view->frame(), m_rootDefaultStyle.get()));
454
455     m_authorStyle = adoptPtr(new CSSRuleSet);
456
457     // FIXME: This sucks! The user sheet is reparsed every time!
458     OwnPtr<CSSRuleSet> tempUserStyle = adoptPtr(new CSSRuleSet);
459     if (pageUserSheet)
460         tempUserStyle->addRulesFromSheet(pageUserSheet, *m_medium, this);
461     if (pageGroupUserSheets) {
462         unsigned length = pageGroupUserSheets->size();
463         for (unsigned i = 0; i < length; i++) {
464             if (pageGroupUserSheets->at(i)->isUserStyleSheet())
465                 tempUserStyle->addRulesFromSheet(pageGroupUserSheets->at(i).get(), *m_medium, this);
466             else
467                 m_authorStyle->addRulesFromSheet(pageGroupUserSheets->at(i).get(), *m_medium, this);
468         }
469     }
470
471     if (tempUserStyle->m_ruleCount > 0 || tempUserStyle->m_pageRuleCount > 0)
472         m_userStyle = tempUserStyle.release();
473
474     // Add rules from elements like SVG's <font-face>
475     if (mappedElementSheet)
476         m_authorStyle->addRulesFromSheet(mappedElementSheet, *m_medium, this);
477
478     // add stylesheets from document
479     unsigned length = styleSheets->length();
480     for (unsigned i = 0; i < length; i++) {
481         StyleSheet* sheet = styleSheets->item(i);
482         if (sheet->isCSSStyleSheet() && !sheet->disabled())
483             m_authorStyle->addRulesFromSheet(static_cast<CSSStyleSheet*>(sheet), *m_medium, this);
484     }
485
486     if (document->renderer() && document->renderer()->style())
487         document->renderer()->style()->font().update(fontSelector());
488 }
489
490 // This is a simplified style setting function for keyframe styles
491 void CSSStyleSelector::addKeyframeStyle(PassRefPtr<WebKitCSSKeyframesRule> rule)
492 {
493     AtomicString s(rule->name());
494     m_keyframesRuleMap.add(s.impl(), rule);
495 }
496
497 CSSStyleSelector::~CSSStyleSelector()
498 {
499     m_fontSelector->clearDocument();
500     deleteAllValues(m_viewportDependentMediaQueryResults);
501 }
502
503 static CSSStyleSheet* parseUASheet(const String& str)
504 {
505     CSSStyleSheet* sheet = CSSStyleSheet::create().releaseRef(); // leak the sheet on purpose
506     sheet->parseString(str);
507     return sheet;
508 }
509
510 static CSSStyleSheet* parseUASheet(const char* characters, unsigned size)
511 {
512     return parseUASheet(String(characters, size));
513 }
514
515 static void loadFullDefaultStyle()
516 {
517     if (simpleDefaultStyleSheet) {
518         ASSERT(defaultStyle);
519         delete defaultStyle;
520         simpleDefaultStyleSheet->deref();
521         defaultStyle = new CSSRuleSet;
522         simpleDefaultStyleSheet = 0;
523     } else {
524         ASSERT(!defaultStyle);
525         defaultStyle = new CSSRuleSet;
526         defaultPrintStyle = new CSSRuleSet;
527         defaultQuirksStyle = new CSSRuleSet;
528     }
529
530     // Strict-mode rules.
531     String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraDefaultStyleSheet();
532     CSSStyleSheet* defaultSheet = parseUASheet(defaultRules);
533     defaultStyle->addRulesFromSheet(defaultSheet, screenEval());
534     defaultPrintStyle->addRulesFromSheet(defaultSheet, printEval());
535
536     // Quirks-mode rules.
537     String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraQuirksStyleSheet();
538     CSSStyleSheet* quirksSheet = parseUASheet(quirksRules);
539     defaultQuirksStyle->addRulesFromSheet(quirksSheet, screenEval());
540     
541 #if ENABLE(FULLSCREEN_API)
542     // Full-screen rules.
543     String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraDefaultStyleSheet();
544     CSSStyleSheet* fullscreenSheet = parseUASheet(fullscreenRules);
545     defaultStyle->addRulesFromSheet(fullscreenSheet, screenEval());
546     defaultQuirksStyle->addRulesFromSheet(fullscreenSheet, screenEval());
547 #endif
548 }
549
550 static void loadSimpleDefaultStyle()
551 {
552     ASSERT(!defaultStyle);
553     ASSERT(!simpleDefaultStyleSheet);
554     
555     defaultStyle = new CSSRuleSet;
556     defaultPrintStyle = new CSSRuleSet;
557     defaultQuirksStyle = new CSSRuleSet;
558
559     simpleDefaultStyleSheet = parseUASheet(simpleUserAgentStyleSheet, strlen(simpleUserAgentStyleSheet));
560     defaultStyle->addRulesFromSheet(simpleDefaultStyleSheet, screenEval());
561     
562     // No need to initialize quirks sheet yet as there are no quirk rules for elements allowed in simple default style.
563 }
564     
565 static void loadViewSourceStyle()
566 {
567     ASSERT(!defaultViewSourceStyle);
568     defaultViewSourceStyle = new CSSRuleSet;
569     defaultViewSourceStyle->addRulesFromSheet(parseUASheet(sourceUserAgentStyleSheet, sizeof(sourceUserAgentStyleSheet)), screenEval());
570 }
571
572 void CSSStyleSelector::addMatchedDeclaration(CSSMutableStyleDeclaration* decl)
573 {
574     if (!decl->hasVariableDependentValue()) {
575         m_matchedDecls.append(decl);
576         return;
577     }
578
579     // See if we have already resolved the variables in this declaration.
580     CSSMutableStyleDeclaration* resolvedDecl = m_resolvedVariablesDeclarations.get(decl).get();
581     if (resolvedDecl) {
582         m_matchedDecls.append(resolvedDecl);
583         return;
584     }
585
586     // If this declaration has any variables in it, then we need to make a cloned
587     // declaration with as many variables resolved as possible for this style selector's media.
588     RefPtr<CSSMutableStyleDeclaration> newDecl = CSSMutableStyleDeclaration::create(decl->parentRule());
589     m_matchedDecls.append(newDecl.get());
590     m_resolvedVariablesDeclarations.set(decl, newDecl);
591
592     HashSet<String> usedBlockVariables;
593     resolveVariablesForDeclaration(decl, newDecl.get(), usedBlockVariables);
594 }
595
596 void CSSStyleSelector::resolveVariablesForDeclaration(CSSMutableStyleDeclaration* decl, CSSMutableStyleDeclaration* newDecl, HashSet<String>& usedBlockVariables)
597 {
598     // Now iterate over the properties in the original declaration.  As we resolve variables we'll end up
599     // mutating the new declaration (possibly expanding shorthands).  The new declaration has no m_node
600     // though, so it can't mistakenly call setChanged on anything.
601     CSSMutableStyleDeclaration::const_iterator end = decl->end();
602     for (CSSMutableStyleDeclaration::const_iterator it = decl->begin(); it != end; ++it) {
603         const CSSProperty& current = *it;
604         if (!current.value()->isVariableDependentValue()) {
605             // We can just add the parsed property directly.
606             newDecl->addParsedProperty(current);
607             continue;
608         }
609         CSSValueList* valueList = static_cast<CSSVariableDependentValue*>(current.value())->valueList();
610         if (!valueList)
611             continue;
612         CSSParserValueList resolvedValueList;
613         unsigned s = valueList->length();
614         bool fullyResolved = true;
615         for (unsigned i = 0; i < s; ++i) {
616             CSSValue* val = valueList->item(i);
617             CSSPrimitiveValue* primitiveValue = val->isPrimitiveValue() ? static_cast<CSSPrimitiveValue*>(val) : 0;
618             if (primitiveValue && primitiveValue->isVariable()) {
619                 CSSVariablesRule* rule = m_variablesMap.get(primitiveValue->getStringValue());
620                 if (!rule || !rule->variables()) {
621                     fullyResolved = false;
622                     break;
623                 }
624                 
625                 if (current.id() == CSSPropertyWebkitVariableDeclarationBlock && s == 1) {
626                     fullyResolved = false;
627                     if (!usedBlockVariables.contains(primitiveValue->getStringValue())) {
628                         CSSMutableStyleDeclaration* declBlock = rule->variables()->getParsedVariableDeclarationBlock(primitiveValue->getStringValue());
629                         if (declBlock) {
630                             usedBlockVariables.add(primitiveValue->getStringValue());
631                             resolveVariablesForDeclaration(declBlock, newDecl, usedBlockVariables);
632                         }
633                     }
634                 }
635
636                 CSSValueList* resolvedVariable = rule->variables()->getParsedVariable(primitiveValue->getStringValue());
637                 if (!resolvedVariable) {
638                     fullyResolved = false;
639                     break;
640                 }
641                 unsigned valueSize = resolvedVariable->length();
642                 for (unsigned j = 0; j < valueSize; ++j)
643                     resolvedValueList.addValue(resolvedVariable->item(j)->parserValue());
644             } else
645                 resolvedValueList.addValue(val->parserValue());
646         }
647         
648         if (!fullyResolved)
649             continue;
650
651         // We now have a fully resolved new value list.  We want the parser to use this value list
652         // and parse our new declaration.
653         CSSParser(m_checker.m_strictParsing).parsePropertyWithResolvedVariables(current.id(), current.isImportant(), newDecl, &resolvedValueList);
654     }
655 }
656
657 void CSSStyleSelector::matchRules(CSSRuleSet* rules, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules)
658 {
659     m_matchedRules.clear();
660
661     if (!rules || !m_element)
662         return;
663     
664     // We need to collect the rules for id, class, tag, and everything else into a buffer and
665     // then sort the buffer.
666     if (m_element->hasID())
667         matchRulesForList(rules->getIDRules(m_element->idForStyleResolution().impl()), firstRuleIndex, lastRuleIndex, includeEmptyRules);
668     if (m_element->hasClass()) {
669         ASSERT(m_styledElement);
670         const SpaceSplitString& classNames = m_styledElement->classNames();
671         size_t size = classNames.size();
672         for (size_t i = 0; i < size; ++i)
673             matchRulesForList(rules->getClassRules(classNames[i].impl()), firstRuleIndex, lastRuleIndex, includeEmptyRules);
674     }
675     matchRulesForList(rules->getTagRules(m_element->localName().impl()), firstRuleIndex, lastRuleIndex, includeEmptyRules);
676     matchRulesForList(rules->getUniversalRules(), firstRuleIndex, lastRuleIndex, includeEmptyRules);
677     
678     // If we didn't match any rules, we're done.
679     if (m_matchedRules.isEmpty())
680         return;
681     
682     // Sort the set of matched rules.
683     sortMatchedRules(0, m_matchedRules.size());
684     
685     // Now transfer the set of matched rules over to our list of decls.
686     if (!m_checker.m_collectRulesOnly) {
687         for (unsigned i = 0; i < m_matchedRules.size(); i++)
688             addMatchedDeclaration(m_matchedRules[i]->rule()->declaration());
689     } else {
690         for (unsigned i = 0; i < m_matchedRules.size(); i++) {
691             if (!m_ruleList)
692                 m_ruleList = CSSRuleList::create();
693             m_ruleList->append(m_matchedRules[i]->rule());
694         }
695     }
696 }
697
698 void CSSStyleSelector::matchRulesForList(CSSRuleDataList* rules, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules)
699 {
700     if (!rules)
701         return;
702
703     for (CSSRuleData* d = rules->first(); d; d = d->next()) {
704         CSSStyleRule* rule = d->rule();
705         if (m_checker.m_sameOriginOnly && !m_checker.m_document->securityOrigin()->canRequest(rule->baseURL()))
706             continue; 
707         if (checkSelector(d->selector())) {
708             // If the rule has no properties to apply, then ignore it in the non-debug mode.
709             CSSMutableStyleDeclaration* decl = rule->declaration();
710             if (!decl || (!decl->length() && !includeEmptyRules))
711                 continue;
712             
713             // If we're matching normal rules, set a pseudo bit if 
714             // we really just matched a pseudo-element.
715             if (m_dynamicPseudo != NOPSEUDO && m_checker.m_pseudoStyle == NOPSEUDO) {
716                 if (m_checker.m_collectRulesOnly)
717                     continue;
718                 if (m_dynamicPseudo < FIRST_INTERNAL_PSEUDOID)
719                     m_style->setHasPseudoStyle(m_dynamicPseudo);
720             } else {
721                 // Update our first/last rule indices in the matched rules array.
722                 lastRuleIndex = m_matchedDecls.size() + m_matchedRules.size();
723                 if (firstRuleIndex == -1)
724                     firstRuleIndex = lastRuleIndex;
725
726                 // Add this rule to our list of matched rules.
727                 addMatchedRule(d);
728             }
729         }
730     }
731 }
732
733 static bool operator >(CSSRuleData& r1, CSSRuleData& r2)
734 {
735     int spec1 = r1.selector()->specificity();
736     int spec2 = r2.selector()->specificity();
737     return (spec1 == spec2) ? r1.position() > r2.position() : spec1 > spec2; 
738 }
739     
740 static bool operator <=(CSSRuleData& r1, CSSRuleData& r2)
741 {
742     return !(r1 > r2);
743 }
744
745 void CSSStyleSelector::sortMatchedRules(unsigned start, unsigned end)
746 {
747     if (start >= end || (end - start == 1))
748         return; // Sanity check.
749
750     if (end - start <= 6) {
751         // Apply a bubble sort for smaller lists.
752         for (unsigned i = end - 1; i > start; i--) {
753             bool sorted = true;
754             for (unsigned j = start; j < i; j++) {
755                 CSSRuleData* elt = m_matchedRules[j];
756                 CSSRuleData* elt2 = m_matchedRules[j + 1];
757                 if (*elt > *elt2) {
758                     sorted = false;
759                     m_matchedRules[j] = elt2;
760                     m_matchedRules[j + 1] = elt;
761                 }
762             }
763             if (sorted)
764                 return;
765         }
766         return;
767     }
768
769     // Perform a merge sort for larger lists.
770     unsigned mid = (start + end) / 2;
771     sortMatchedRules(start, mid);
772     sortMatchedRules(mid, end);
773     
774     CSSRuleData* elt = m_matchedRules[mid - 1];
775     CSSRuleData* elt2 = m_matchedRules[mid];
776     
777     // Handle the fast common case (of equal specificity).  The list may already
778     // be completely sorted.
779     if (*elt <= *elt2)
780         return;
781     
782     // We have to merge sort.  Ensure our merge buffer is big enough to hold
783     // all the items.
784     Vector<CSSRuleData*> rulesMergeBuffer;
785     rulesMergeBuffer.reserveInitialCapacity(end - start); 
786
787     unsigned i1 = start;
788     unsigned i2 = mid;
789     
790     elt = m_matchedRules[i1];
791     elt2 = m_matchedRules[i2];
792     
793     while (i1 < mid || i2 < end) {
794         if (i1 < mid && (i2 == end || *elt <= *elt2)) {
795             rulesMergeBuffer.append(elt);
796             if (++i1 < mid)
797                 elt = m_matchedRules[i1];
798         } else {
799             rulesMergeBuffer.append(elt2);
800             if (++i2 < end)
801                 elt2 = m_matchedRules[i2];
802         }
803     }
804     
805     for (unsigned i = start; i < end; i++)
806         m_matchedRules[i] = rulesMergeBuffer[i - start];
807 }
808
809 inline EInsideLink CSSStyleSelector::SelectorChecker::determineLinkState(Element* element) const
810 {
811     if (!element || !element->isLink())
812         return NotInsideLink;
813     return determineLinkStateSlowCase(element);
814 }
815     
816 inline void CSSStyleSelector::initElement(Element* e)
817 {
818     if (m_element != e) {
819         m_element = e;
820         m_styledElement = m_element && m_element->isStyledElement() ? static_cast<StyledElement*>(m_element) : 0;
821         m_elementLinkState = m_checker.determineLinkState(m_element);
822         if (e && e == e->document()->documentElement()) {
823             e->document()->setDirectionSetOnDocumentElement(false);
824             e->document()->setWritingModeSetOnDocumentElement(false);
825         }
826     }
827 }
828
829 inline void CSSStyleSelector::initForStyleResolve(Element* e, RenderStyle* parentStyle, PseudoId pseudoID)
830 {
831     m_checker.m_pseudoStyle = pseudoID;
832
833     m_parentNode = e ? e->parentNode() : 0;
834
835 #if ENABLE(SVG)
836     if (!m_parentNode && e && e->isSVGElement() && e->isShadowNode())
837         m_parentNode = e->shadowParentNode();
838 #endif
839
840     if (parentStyle)
841         m_parentStyle = parentStyle;
842     else
843         m_parentStyle = m_parentNode ? m_parentNode->renderStyle() : 0;
844
845     Node* docElement = e ? e->document()->documentElement() : 0;
846     RenderStyle* docStyle = m_checker.m_document->renderStyle();
847     m_rootElementStyle = docElement && e != docElement ? docElement->renderStyle() : docStyle;
848
849     m_style = 0;
850
851     m_matchedDecls.clear();
852
853     m_pendingImageProperties.clear();
854
855     m_ruleList = 0;
856
857     m_fontDirty = false;
858 }
859
860 static inline const AtomicString* linkAttribute(Node* node)
861 {
862     if (!node->isLink())
863         return 0;
864
865     ASSERT(node->isElementNode());
866     Element* element = static_cast<Element*>(node);
867     if (element->isHTMLElement())
868         return &element->fastGetAttribute(hrefAttr);
869
870 #if ENABLE(WML)
871     if (element->isWMLElement()) {
872         // <anchor> elements don't have href attributes, but we still want to
873         // appear as link, so linkAttribute() has to return a non-null value!
874         if (element->hasTagName(WMLNames::anchorTag))
875             return &emptyAtom;
876
877         return &element->fastGetAttribute(hrefAttr);
878     }
879 #endif
880
881 #if ENABLE(SVG)
882     if (element->isSVGElement())
883         return &element->fastGetAttribute(XLinkNames::hrefAttr);
884 #endif
885
886     return 0;
887 }
888
889 CSSStyleSelector::SelectorChecker::SelectorChecker(Document* document, bool strictParsing)
890     : m_document(document)
891     , m_strictParsing(strictParsing)
892     , m_collectRulesOnly(false)
893     , m_sameOriginOnly(false)
894     , m_pseudoStyle(NOPSEUDO)
895     , m_documentIsHTML(document->isHTMLDocument())
896     , m_matchVisitedPseudoClass(false)
897 {
898 }
899
900 EInsideLink CSSStyleSelector::SelectorChecker::determineLinkStateSlowCase(Element* element) const
901 {
902     ASSERT(element->isLink());
903     
904     const AtomicString* attr = linkAttribute(element);
905     if (!attr || attr->isNull())
906         return NotInsideLink;
907
908 #if PLATFORM(QT)
909     Vector<UChar, 512> url;
910     visitedURL(m_document->baseURL(), *attr, url);
911     if (url.isEmpty())
912         return InsideUnvisitedLink;
913
914     // If the Qt4.4 interface for the history is used, we will have to fallback
915     // to the old global history.
916     QWebHistoryInterface* iface = QWebHistoryInterface::defaultInterface();
917     if (iface)
918         return iface->historyContains(QString(reinterpret_cast<QChar*>(url.data()), url.size())) ? InsideVisitedLink : InsideUnvisitedLink;
919
920     LinkHash hash = visitedLinkHash(url.data(), url.size());
921     if (!hash)
922         return InsideUnvisitedLink;
923 #else
924     LinkHash hash = visitedLinkHash(m_document->baseURL(), *attr);
925     if (!hash)
926         return InsideUnvisitedLink;
927 #endif
928
929     Frame* frame = m_document->frame();
930     if (!frame)
931         return InsideUnvisitedLink;
932
933     Page* page = frame->page();
934     if (!page)
935         return InsideUnvisitedLink;
936
937     m_linksCheckedForVisitedState.add(hash);
938
939 #if USE(PLATFORM_STRATEGIES)
940     return platformStrategies()->visitedLinkStrategy()->isLinkVisited(page, hash) ? InsideVisitedLink : InsideUnvisitedLink;
941 #else
942     return page->group().isLinkVisited(hash) ? InsideVisitedLink : InsideUnvisitedLink;
943 #endif
944 }
945
946 bool CSSStyleSelector::SelectorChecker::checkSelector(CSSSelector* sel, Element* element) const
947 {
948     PseudoId dynamicPseudo = NOPSEUDO;
949     return checkSelector(sel, element, 0, dynamicPseudo, false, false) == SelectorMatches;
950 }
951
952 static const unsigned cStyleSearchThreshold = 10;
953
954 Node* CSSStyleSelector::locateCousinList(Element* parent, unsigned depth)
955 {
956     if (parent && parent->isStyledElement()) {
957         StyledElement* p = static_cast<StyledElement*>(parent);
958         if (!p->inlineStyleDecl() && !p->hasID()) {
959             Node* r = p->previousSibling();
960             unsigned subcount = 0;
961             RenderStyle* st = p->renderStyle();
962             while (r) {
963                 if (r->renderStyle() == st)
964                     return r->lastChild();
965                 if (subcount++ == cStyleSearchThreshold)
966                     return 0;
967                 r = r->previousSibling();
968             }
969             if (!r && depth < cStyleSearchThreshold)
970                 r = locateCousinList(parent->parentElement(), depth + 1);
971             while (r) {
972                 if (r->renderStyle() == st)
973                     return r->lastChild();
974                 if (subcount++ == cStyleSearchThreshold)
975                     return 0;
976                 r = r->previousSibling();
977             }
978         }
979     }
980     return 0;
981 }
982
983 bool CSSStyleSelector::canShareStyleWithElement(Node* n)
984 {
985     if (n->isStyledElement()) {
986         StyledElement* s = static_cast<StyledElement*>(n);
987         RenderStyle* style = s->renderStyle();
988         if (style && !style->unique() &&
989             (s->tagQName() == m_element->tagQName()) && !s->hasID() &&
990             (s->hasClass() == m_element->hasClass()) && !s->inlineStyleDecl() &&
991             (s->hasMappedAttributes() == m_styledElement->hasMappedAttributes()) &&
992             (s->isLink() == m_element->isLink()) && 
993             !style->affectedByAttributeSelectors() &&
994             (s->hovered() == m_element->hovered()) &&
995             (s->active() == m_element->active()) &&
996             (s->focused() == m_element->focused()) &&
997             (s != s->document()->cssTarget() && m_element != m_element->document()->cssTarget()) &&
998             (s->fastGetAttribute(typeAttr) == m_element->fastGetAttribute(typeAttr)) &&
999             (s->fastGetAttribute(XMLNames::langAttr) == m_element->fastGetAttribute(XMLNames::langAttr)) &&
1000             (s->fastGetAttribute(langAttr) == m_element->fastGetAttribute(langAttr)) &&
1001             (s->fastGetAttribute(readonlyAttr) == m_element->fastGetAttribute(readonlyAttr)) &&
1002             (s->fastGetAttribute(cellpaddingAttr) == m_element->fastGetAttribute(cellpaddingAttr))) {
1003             bool isControl = s->isFormControlElement();
1004             if (isControl != m_element->isFormControlElement())
1005                 return false;
1006             if (isControl) {
1007                 InputElement* thisInputElement = toInputElement(s);
1008                 InputElement* otherInputElement = toInputElement(m_element);
1009                 if (thisInputElement && otherInputElement) {
1010                     if ((thisInputElement->isAutofilled() != otherInputElement->isAutofilled()) ||
1011                         (thisInputElement->isChecked() != otherInputElement->isChecked()) ||
1012                         (thisInputElement->isIndeterminate() != otherInputElement->isIndeterminate()))
1013                     return false;
1014                 } else
1015                     return false;
1016
1017                 if (s->isEnabledFormControl() != m_element->isEnabledFormControl())
1018                     return false;
1019
1020                 if (s->isDefaultButtonForForm() != m_element->isDefaultButtonForForm())
1021                     return false;
1022                 
1023                 if (!m_element->document()->containsValidityStyleRules())
1024                     return false;
1025                 
1026                 bool willValidate = s->willValidate();
1027                 if (willValidate != m_element->willValidate())
1028                     return false;
1029                 
1030                 if (willValidate && (s->isValidFormControlElement() != m_element->isValidFormControlElement()))
1031                     return false;
1032             }
1033
1034             if (style->transitions() || style->animations())
1035                 return false;
1036
1037 #if USE(ACCELERATED_COMPOSITING)
1038             // Turn off style sharing for elements that can gain layers for reasons outside of the style system.
1039             // See comments in RenderObject::setStyle().
1040             if (s->hasTagName(iframeTag) || s->hasTagName(embedTag) || s->hasTagName(objectTag) || s->hasTagName(appletTag))
1041                 return false;
1042 #endif
1043
1044             bool classesMatch = true;
1045             if (s->hasClass()) {
1046                 const AtomicString& class1 = m_element->fastGetAttribute(classAttr);
1047                 const AtomicString& class2 = s->fastGetAttribute(classAttr);
1048                 classesMatch = (class1 == class2);
1049             }
1050             
1051             if (classesMatch) {
1052                 bool mappedAttrsMatch = true;
1053                 if (s->hasMappedAttributes())
1054                     mappedAttrsMatch = s->attributeMap()->mappedMapsEquivalent(m_styledElement->attributeMap());
1055                 if (mappedAttrsMatch) {
1056                     if (s->isLink()) {
1057                         if (m_elementLinkState != style->insideLink())
1058                             return false;
1059                     }
1060                     return true;
1061                 }
1062             }
1063         }
1064     }
1065     return false;
1066 }
1067
1068 ALWAYS_INLINE RenderStyle* CSSStyleSelector::locateSharedStyle()
1069 {
1070     if (m_styledElement && !m_styledElement->inlineStyleDecl() && !m_styledElement->hasID() && !m_styledElement->document()->usesSiblingRules()) {
1071         // Check previous siblings.
1072         unsigned count = 0;
1073         Node* n;
1074         for (n = m_element->previousSibling(); n && !n->isElementNode(); n = n->previousSibling()) { }
1075         while (n) {
1076             if (canShareStyleWithElement(n))
1077                 return n->renderStyle();
1078             if (count++ == cStyleSearchThreshold)
1079                 return 0;
1080             for (n = n->previousSibling(); n && !n->isElementNode(); n = n->previousSibling()) { }
1081         }
1082         if (!n) 
1083             n = locateCousinList(m_element->parentElement());
1084         while (n) {
1085             if (canShareStyleWithElement(n))
1086                 return n->renderStyle();
1087             if (count++ == cStyleSearchThreshold)
1088                 return 0;
1089             for (n = n->previousSibling(); n && !n->isElementNode(); n = n->previousSibling()) { }
1090         }        
1091     }
1092     return 0;
1093 }
1094
1095 void CSSStyleSelector::matchUARules(int& firstUARule, int& lastUARule)
1096 {
1097     // First we match rules from the user agent sheet.
1098     CSSRuleSet* userAgentStyleSheet = m_medium->mediaTypeMatchSpecific("print")
1099         ? defaultPrintStyle : defaultStyle;
1100     matchRules(userAgentStyleSheet, firstUARule, lastUARule, false);
1101
1102     // In quirks mode, we match rules from the quirks user agent sheet.
1103     if (!m_checker.m_strictParsing)
1104         matchRules(defaultQuirksStyle, firstUARule, lastUARule, false);
1105         
1106     // If we're in view source mode, then we match rules from the view source style sheet.
1107     if (m_checker.m_document->frame() && m_checker.m_document->frame()->inViewSourceMode()) {
1108         if (!defaultViewSourceStyle)
1109             loadViewSourceStyle();
1110         matchRules(defaultViewSourceStyle, firstUARule, lastUARule, false);
1111     }
1112 }
1113
1114 PassRefPtr<RenderStyle> CSSStyleSelector::styleForDocument(Document* document)
1115 {
1116     Frame* frame = document->frame();
1117
1118     RefPtr<RenderStyle> documentStyle = RenderStyle::create();
1119     documentStyle->setDisplay(BLOCK);
1120     documentStyle->setVisuallyOrdered(document->visuallyOrdered());
1121     documentStyle->setZoom(frame ? frame->pageZoomFactor() : 1);
1122     documentStyle->setPageScaleTransform(frame ? frame->pageScaleFactor() : 1);
1123     
1124     Element* docElement = document->documentElement();
1125     RenderObject* docElementRenderer = docElement ? docElement->renderer() : 0;
1126     if (docElementRenderer) {
1127         // Use the direction and writing-mode of the body to set the
1128         // viewport's direction and writing-mode unless the property is set on the document element.
1129         // If there is no body, then use the document element.
1130         RenderObject* bodyRenderer = document->body() ? document->body()->renderer() : 0;
1131         if (bodyRenderer && !document->writingModeSetOnDocumentElement())
1132             documentStyle->setWritingMode(bodyRenderer->style()->writingMode());
1133         else
1134             documentStyle->setWritingMode(docElementRenderer->style()->writingMode());
1135         if (bodyRenderer && !document->directionSetOnDocumentElement())
1136             documentStyle->setDirection(bodyRenderer->style()->direction());
1137         else
1138             documentStyle->setDirection(docElementRenderer->style()->direction());
1139     }
1140
1141     FontDescription fontDescription;
1142     fontDescription.setUsePrinterFont(document->printing());
1143     if (Settings* settings = document->settings()) {
1144         fontDescription.setRenderingMode(settings->fontRenderingMode());
1145         if (document->printing() && !settings->shouldPrintBackgrounds())
1146             documentStyle->setForceBackgroundsToWhite(true);
1147         const AtomicString& stdfont = settings->standardFontFamily();
1148         if (!stdfont.isEmpty()) {
1149             fontDescription.firstFamily().setFamily(stdfont);
1150             fontDescription.firstFamily().appendFamily(0);
1151         }
1152         fontDescription.setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
1153         int size = CSSStyleSelector::fontSizeForKeyword(document, CSSValueMedium, false);
1154         fontDescription.setSpecifiedSize(size);
1155         bool useSVGZoomRules = document->isSVGDocument();
1156         fontDescription.setComputedSize(CSSStyleSelector::getComputedSizeFromSpecifiedSize(document, documentStyle.get(), fontDescription.isAbsoluteSize(), size, useSVGZoomRules));
1157     }
1158
1159     documentStyle->setFontDescription(fontDescription);
1160     documentStyle->font().update(0);
1161         
1162     return documentStyle.release();
1163 }
1164
1165 // If resolveForRootDefault is true, style based on user agent style sheet only. This is used in media queries, where
1166 // relative units are interpreted according to document root element style, styled only with UA stylesheet
1167
1168 PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* e, RenderStyle* defaultParent, bool allowSharing, bool resolveForRootDefault, bool matchVisitedPseudoClass)
1169 {
1170     // Once an element has a renderer, we don't try to destroy it, since otherwise the renderer
1171     // will vanish if a style recalc happens during loading.
1172     if (allowSharing && !e->document()->haveStylesheetsLoaded() && !e->renderer()) {
1173         if (!s_styleNotYetAvailable) {
1174             s_styleNotYetAvailable = RenderStyle::create().releaseRef();
1175             s_styleNotYetAvailable->ref();
1176             s_styleNotYetAvailable->setDisplay(NONE);
1177             s_styleNotYetAvailable->font().update(m_fontSelector);
1178         }
1179         s_styleNotYetAvailable->ref();
1180         e->document()->setHasNodesWithPlaceholderStyle();
1181         return s_styleNotYetAvailable;
1182     }
1183
1184     initElement(e);
1185     if (allowSharing) {
1186         RenderStyle* sharedStyle = locateSharedStyle();
1187         if (sharedStyle)
1188             return sharedStyle;
1189     }
1190     initForStyleResolve(e, defaultParent);
1191
1192     // Compute our style allowing :visited to match first.
1193     RefPtr<RenderStyle> visitedStyle;
1194     if (!matchVisitedPseudoClass && m_parentStyle && (m_parentStyle->insideLink() || e->isLink()) && e->document()->usesLinkRules()) {
1195         // Fetch our parent style.
1196         RenderStyle* parentStyle = m_parentStyle;
1197         if (!e->isLink()) {
1198             // Use the parent's visited style if one exists.
1199             RenderStyle* parentVisitedStyle = m_parentStyle->getCachedPseudoStyle(VISITED_LINK);
1200             if (parentVisitedStyle)
1201                 parentStyle = parentVisitedStyle;
1202         }
1203         visitedStyle = styleForElement(e, parentStyle, false, false, true);
1204         if (visitedStyle) {
1205             if (m_elementLinkState == InsideUnvisitedLink)
1206                 visitedStyle = 0;  // We made the style to avoid timing attacks. Just throw it away now that we did that, since we don't need it.
1207             else
1208                 visitedStyle->setStyleType(VISITED_LINK);
1209         }
1210         initForStyleResolve(e, defaultParent);
1211     }
1212
1213     m_checker.m_matchVisitedPseudoClass = matchVisitedPseudoClass;
1214
1215     m_style = RenderStyle::create();
1216
1217     if (m_parentStyle)
1218         m_style->inheritFrom(m_parentStyle);
1219     else
1220         m_parentStyle = style();
1221
1222     if (e->isLink()) {
1223         m_style->setIsLink(true);
1224         m_style->setInsideLink(m_elementLinkState);
1225     }
1226     
1227     if (simpleDefaultStyleSheet && !elementCanUseSimpleDefaultStyle(e))
1228         loadFullDefaultStyle();
1229
1230 #if ENABLE(SVG)
1231     static bool loadedSVGUserAgentSheet;
1232     if (e->isSVGElement() && !loadedSVGUserAgentSheet) {
1233         // SVG rules.
1234         loadedSVGUserAgentSheet = true;
1235         CSSStyleSheet* svgSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet));
1236         defaultStyle->addRulesFromSheet(svgSheet, screenEval());
1237         defaultPrintStyle->addRulesFromSheet(svgSheet, printEval());
1238     }
1239 #endif
1240
1241 #if ENABLE(MATHML)
1242     static bool loadedMathMLUserAgentSheet;
1243     if (e->isMathMLElement() && !loadedMathMLUserAgentSheet) {
1244         // MathML rules.
1245         loadedMathMLUserAgentSheet = true;
1246         CSSStyleSheet* mathMLSheet = parseUASheet(mathmlUserAgentStyleSheet, sizeof(mathmlUserAgentStyleSheet));
1247         defaultStyle->addRulesFromSheet(mathMLSheet, screenEval());
1248         defaultPrintStyle->addRulesFromSheet(mathMLSheet, printEval());
1249     }
1250 #endif
1251
1252 #if ENABLE(WML)
1253     static bool loadedWMLUserAgentSheet;
1254     if (e->isWMLElement() && !loadedWMLUserAgentSheet) {
1255         // WML rules.
1256         loadedWMLUserAgentSheet = true;
1257         CSSStyleSheet* wmlSheet = parseUASheet(wmlUserAgentStyleSheet, sizeof(wmlUserAgentStyleSheet));
1258         defaultStyle->addRulesFromSheet(wmlSheet, screenEval());
1259         defaultPrintStyle->addRulesFromSheet(wmlSheet, printEval());
1260     }
1261 #endif
1262
1263 #if ENABLE(VIDEO)
1264     static bool loadedMediaStyleSheet;
1265     if (!loadedMediaStyleSheet && (e->hasTagName(videoTag) || e->hasTagName(audioTag))) {
1266         loadedMediaStyleSheet = true;
1267         String mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraMediaControlsStyleSheet();
1268         CSSStyleSheet* mediaControlsSheet = parseUASheet(mediaRules);
1269         defaultStyle->addRulesFromSheet(mediaControlsSheet, screenEval());
1270         defaultPrintStyle->addRulesFromSheet(mediaControlsSheet, printEval());
1271     }
1272 #endif
1273
1274     int firstUARule = -1, lastUARule = -1;
1275     int firstUserRule = -1, lastUserRule = -1;
1276     int firstAuthorRule = -1, lastAuthorRule = -1;
1277     matchUARules(firstUARule, lastUARule);
1278
1279     if (!resolveForRootDefault) {
1280         // 4. Now we check user sheet rules.
1281         if (m_matchAuthorAndUserStyles)
1282             matchRules(m_userStyle.get(), firstUserRule, lastUserRule, false);
1283
1284         // 5. Now check author rules, beginning first with presentational attributes
1285         // mapped from HTML.
1286         if (m_styledElement) {
1287             // Ask if the HTML element has mapped attributes.
1288             if (m_styledElement->hasMappedAttributes()) {
1289                 // Walk our attribute list and add in each decl.
1290                 const NamedNodeMap* map = m_styledElement->attributeMap();
1291                 for (unsigned i = 0; i < map->length(); i++) {
1292                     Attribute* attr = map->attributeItem(i);
1293                     if (attr->isMappedAttribute() && attr->decl()) {
1294                         lastAuthorRule = m_matchedDecls.size();
1295                         if (firstAuthorRule == -1)
1296                             firstAuthorRule = lastAuthorRule;
1297                         addMatchedDeclaration(attr->decl());
1298                     }
1299                 }
1300             }
1301
1302             // Now we check additional mapped declarations.
1303             // Tables and table cells share an additional mapped rule that must be applied
1304             // after all attributes, since their mapped style depends on the values of multiple attributes.
1305             if (m_styledElement->canHaveAdditionalAttributeStyleDecls()) {
1306                 m_additionalAttributeStyleDecls.clear();
1307                 m_styledElement->additionalAttributeStyleDecls(m_additionalAttributeStyleDecls);
1308                 if (!m_additionalAttributeStyleDecls.isEmpty()) {
1309                     unsigned additionalDeclsSize = m_additionalAttributeStyleDecls.size();
1310                     if (firstAuthorRule == -1)
1311                         firstAuthorRule = m_matchedDecls.size();
1312                     lastAuthorRule = m_matchedDecls.size() + additionalDeclsSize - 1;
1313                     for (unsigned i = 0; i < additionalDeclsSize; i++)
1314                         addMatchedDeclaration(m_additionalAttributeStyleDecls[i]);
1315                 }
1316             }
1317         }
1318     
1319         // 6. Check the rules in author sheets next.
1320         if (m_matchAuthorAndUserStyles)
1321             matchRules(m_authorStyle.get(), firstAuthorRule, lastAuthorRule, false);
1322
1323         // 7. Now check our inline style attribute.
1324         if (m_matchAuthorAndUserStyles && m_styledElement) {
1325             CSSMutableStyleDeclaration* inlineDecl = m_styledElement->inlineStyleDecl();
1326             if (inlineDecl) {
1327                 lastAuthorRule = m_matchedDecls.size();
1328                 if (firstAuthorRule == -1)
1329                     firstAuthorRule = lastAuthorRule;
1330                 addMatchedDeclaration(inlineDecl);
1331             }
1332         }
1333     }
1334
1335     // Reset the value back before applying properties, so that -webkit-link knows what color to use.
1336     m_checker.m_matchVisitedPseudoClass = matchVisitedPseudoClass;
1337     
1338     // Now we have all of the matched rules in the appropriate order.  Walk the rules and apply
1339     // high-priority properties first, i.e., those properties that other properties depend on.
1340     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
1341     // and (4) normal important.
1342     m_lineHeightValue = 0;
1343     applyDeclarations<true>(false, 0, m_matchedDecls.size() - 1);
1344     if (!resolveForRootDefault) {
1345         applyDeclarations<true>(true, firstAuthorRule, lastAuthorRule);
1346         applyDeclarations<true>(true, firstUserRule, lastUserRule);
1347     }
1348     applyDeclarations<true>(true, firstUARule, lastUARule);
1349     
1350     // If our font got dirtied, go ahead and update it now.
1351     if (m_fontDirty)
1352         updateFont();
1353
1354     // Line-height is set when we are sure we decided on the font-size
1355     if (m_lineHeightValue)
1356         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
1357
1358     // Now do the normal priority UA properties.
1359     applyDeclarations<false>(false, firstUARule, lastUARule);
1360     
1361     // Cache our border and background so that we can examine them later.
1362     cacheBorderAndBackground();
1363     
1364     // Now do the author and user normal priority properties and all the !important properties.
1365     if (!resolveForRootDefault) {
1366         applyDeclarations<false>(false, lastUARule + 1, m_matchedDecls.size() - 1);
1367         applyDeclarations<false>(true, firstAuthorRule, lastAuthorRule);
1368         applyDeclarations<false>(true, firstUserRule, lastUserRule);
1369     }
1370     applyDeclarations<false>(true, firstUARule, lastUARule);
1371
1372     ASSERT(!m_fontDirty);
1373     // If our font got dirtied by one of the non-essential font props, 
1374     // go ahead and update it a second time.
1375     if (m_fontDirty)
1376         updateFont();
1377     
1378     // Clean up our style object's display and text decorations (among other fixups).
1379     adjustRenderStyle(style(), m_parentStyle, e);
1380
1381     // Start loading images referenced by this style.
1382     loadPendingImages();
1383
1384     // If we have first-letter pseudo style, do not share this style
1385     if (m_style->hasPseudoStyle(FIRST_LETTER))
1386         m_style->setUnique();
1387
1388     if (visitedStyle) {
1389         // Copy any pseudo bits that the visited style has to the primary style so that
1390         // pseudo element styles will continue to work for pseudo elements inside :visited
1391         // links.
1392         for (unsigned pseudo = FIRST_PUBLIC_PSEUDOID; pseudo < FIRST_INTERNAL_PSEUDOID; ++pseudo) {
1393             if (visitedStyle->hasPseudoStyle(static_cast<PseudoId>(pseudo)))
1394                 m_style->setHasPseudoStyle(static_cast<PseudoId>(pseudo));
1395         }
1396         
1397         // Add the visited style off the main style.
1398         m_style->addCachedPseudoStyle(visitedStyle.release());
1399     }
1400
1401     if (!matchVisitedPseudoClass)
1402         initElement(0); // Clear out for the next resolve.
1403
1404     // Now return the style.
1405     return m_style.release();
1406 }
1407
1408 PassRefPtr<RenderStyle> CSSStyleSelector::styleForKeyframe(const RenderStyle* elementStyle, const WebKitCSSKeyframeRule* keyframeRule, KeyframeValue& keyframe)
1409 {
1410     if (keyframeRule->style())
1411         addMatchedDeclaration(keyframeRule->style());
1412
1413     ASSERT(!m_style);
1414
1415     // Create the style
1416     m_style = RenderStyle::clone(elementStyle);
1417
1418     m_lineHeightValue = 0;
1419
1420     // We don't need to bother with !important. Since there is only ever one
1421     // decl, there's nothing to override. So just add the first properties.
1422     if (keyframeRule->style())
1423         applyDeclarations<true>(false, 0, m_matchedDecls.size() - 1);
1424
1425     // If our font got dirtied, go ahead and update it now.
1426     if (m_fontDirty)
1427         updateFont();
1428
1429     // Line-height is set when we are sure we decided on the font-size
1430     if (m_lineHeightValue)
1431         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
1432
1433     // Now do rest of the properties.
1434     if (keyframeRule->style())
1435         applyDeclarations<false>(false, 0, m_matchedDecls.size() - 1);
1436
1437     // If our font got dirtied by one of the non-essential font props,
1438     // go ahead and update it a second time.
1439     if (m_fontDirty)
1440         updateFont();
1441
1442     // Start loading images referenced by this style.
1443     loadPendingImages();
1444
1445     // Add all the animating properties to the keyframe.
1446     if (keyframeRule->style()) {
1447         CSSMutableStyleDeclaration::const_iterator end = keyframeRule->style()->end();
1448         for (CSSMutableStyleDeclaration::const_iterator it = keyframeRule->style()->begin(); it != end; ++it) {
1449             int property = (*it).id();
1450             // Timing-function within keyframes is special, because it is not animated; it just
1451             // describes the timing function between this keyframe and the next.
1452             if (property != CSSPropertyWebkitAnimationTimingFunction)
1453                 keyframe.addProperty(property);
1454         }
1455     }
1456
1457     return m_style.release();
1458 }
1459
1460 void CSSStyleSelector::keyframeStylesForAnimation(Element* e, const RenderStyle* elementStyle, KeyframeList& list)
1461 {
1462     list.clear();
1463     
1464     // Get the keyframesRule for this name
1465     if (!e || list.animationName().isEmpty())
1466         return;
1467
1468     m_keyframesRuleMap.checkConsistency();
1469    
1470     if (!m_keyframesRuleMap.contains(list.animationName().impl()))
1471         return;
1472         
1473     const WebKitCSSKeyframesRule* rule = m_keyframesRuleMap.find(list.animationName().impl()).get()->second.get();
1474     
1475     // Construct and populate the style for each keyframe
1476     for (unsigned i = 0; i < rule->length(); ++i) {
1477         // Apply the declaration to the style. This is a simplified version of the logic in styleForElement
1478         initElement(e);
1479         initForStyleResolve(e);
1480         
1481         const WebKitCSSKeyframeRule* keyframeRule = rule->item(i);
1482
1483         KeyframeValue keyframe(0, 0);
1484         keyframe.setStyle(styleForKeyframe(elementStyle, keyframeRule, keyframe));
1485
1486         // Add this keyframe style to all the indicated key times
1487         Vector<float> keys;
1488         keyframeRule->getKeys(keys);
1489         for (size_t keyIndex = 0; keyIndex < keys.size(); ++keyIndex) {
1490             keyframe.setKey(keys[keyIndex]);
1491             list.insert(keyframe);
1492         }
1493     }
1494     
1495     // If the 0% keyframe is missing, create it (but only if there is at least one other keyframe)
1496     int initialListSize = list.size();
1497     if (initialListSize > 0 && list[0].key() != 0) {
1498         RefPtr<WebKitCSSKeyframeRule> keyframeRule = WebKitCSSKeyframeRule::create();
1499         keyframeRule->setKeyText("0%");
1500         KeyframeValue keyframe(0, 0);
1501         keyframe.setStyle(styleForKeyframe(elementStyle, keyframeRule.get(), keyframe));
1502         list.insert(keyframe);
1503     }
1504
1505     // If the 100% keyframe is missing, create it (but only if there is at least one other keyframe)
1506     if (initialListSize > 0 && (list[list.size() - 1].key() != 1)) {
1507         RefPtr<WebKitCSSKeyframeRule> keyframeRule = WebKitCSSKeyframeRule::create();
1508         keyframeRule->setKeyText("100%");
1509         KeyframeValue keyframe(1, 0);
1510         keyframe.setStyle(styleForKeyframe(elementStyle, keyframeRule.get(), keyframe));
1511         list.insert(keyframe);
1512     }
1513 }
1514
1515 PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForElement(PseudoId pseudo, Element* e, RenderStyle* parentStyle, bool matchVisitedPseudoClass)
1516 {
1517     if (!e)
1518         return 0;
1519
1520     initElement(e);
1521
1522     // Compute our :visited style first, so that we know whether or not we'll need to create a normal style just to hang it
1523     // off of.
1524     RefPtr<RenderStyle> visitedStyle;
1525     if (!matchVisitedPseudoClass && parentStyle && parentStyle->insideLink()) {
1526         // Fetch our parent style with :visited in effect.
1527         RenderStyle* parentVisitedStyle = parentStyle->getCachedPseudoStyle(VISITED_LINK);
1528         visitedStyle = pseudoStyleForElement(pseudo, e, parentVisitedStyle ? parentVisitedStyle : parentStyle, true);
1529         if (visitedStyle) {
1530             if (m_elementLinkState == InsideUnvisitedLink)
1531                 visitedStyle = 0;  // We made the style to avoid timing attacks. Just throw it away now that we did that.
1532             else
1533                 visitedStyle->setStyleType(VISITED_LINK);
1534         }
1535     }
1536
1537     initForStyleResolve(e, parentStyle, pseudo);
1538     m_style = RenderStyle::create();
1539     if (parentStyle)
1540         m_style->inheritFrom(parentStyle);
1541
1542     m_checker.m_matchVisitedPseudoClass = matchVisitedPseudoClass;
1543
1544     // Since we don't use pseudo-elements in any of our quirk/print user agent rules, don't waste time walking
1545     // those rules.
1546     
1547     // Check UA, user and author rules.
1548     int firstUARule = -1, lastUARule = -1, firstUserRule = -1, lastUserRule = -1, firstAuthorRule = -1, lastAuthorRule = -1;
1549     matchUARules(firstUARule, lastUARule);
1550
1551     if (m_matchAuthorAndUserStyles) {
1552         matchRules(m_userStyle.get(), firstUserRule, lastUserRule, false);
1553         matchRules(m_authorStyle.get(), firstAuthorRule, lastAuthorRule, false);
1554     }
1555
1556     if (m_matchedDecls.isEmpty() && !visitedStyle)
1557         return 0;
1558
1559     m_style->setStyleType(pseudo);
1560     
1561     m_lineHeightValue = 0;
1562     
1563     // Reset the value back before applying properties, so that -webkit-link knows what color to use.
1564     m_checker.m_matchVisitedPseudoClass = matchVisitedPseudoClass;
1565
1566     // High-priority properties.
1567     applyDeclarations<true>(false, 0, m_matchedDecls.size() - 1);
1568     applyDeclarations<true>(true, firstAuthorRule, lastAuthorRule);
1569     applyDeclarations<true>(true, firstUserRule, lastUserRule);
1570     applyDeclarations<true>(true, firstUARule, lastUARule);
1571     
1572     // If our font got dirtied, go ahead and update it now.
1573     if (m_fontDirty)
1574         updateFont();
1575
1576     // Line-height is set when we are sure we decided on the font-size
1577     if (m_lineHeightValue)
1578         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
1579     
1580     // Now do the normal priority properties.
1581     applyDeclarations<false>(false, firstUARule, lastUARule);
1582     
1583     // Cache our border and background so that we can examine them later.
1584     cacheBorderAndBackground();
1585     
1586     applyDeclarations<false>(false, lastUARule + 1, m_matchedDecls.size() - 1);
1587     applyDeclarations<false>(true, firstAuthorRule, lastAuthorRule);
1588     applyDeclarations<false>(true, firstUserRule, lastUserRule);
1589     applyDeclarations<false>(true, firstUARule, lastUARule);
1590     
1591     // If our font got dirtied by one of the non-essential font props, 
1592     // go ahead and update it a second time.
1593     if (m_fontDirty)
1594         updateFont();
1595
1596     // Clean up our style object's display and text decorations (among other fixups).
1597     adjustRenderStyle(style(), parentStyle, 0);
1598
1599     // Start loading images referenced by this style.
1600     loadPendingImages();
1601
1602     // Hang our visited style off m_style.
1603     if (visitedStyle)
1604         m_style->addCachedPseudoStyle(visitedStyle.release());
1605         
1606     // Now return the style.
1607     return m_style.release();
1608 }
1609
1610 PassRefPtr<RenderStyle> CSSStyleSelector::styleForPage(int pageIndex)
1611 {
1612     initForStyleResolve(m_checker.m_document->documentElement()); // m_rootElementStyle will be set to the document style.
1613
1614     m_style = RenderStyle::create();
1615     m_style->inheritFrom(m_rootElementStyle);
1616
1617     const bool isLeft = isLeftPage(pageIndex);
1618     const bool isFirst = isFirstPage(pageIndex);
1619     const String page = pageName(pageIndex);
1620     matchPageRules(defaultPrintStyle, isLeft, isFirst, page);
1621     matchPageRules(m_userStyle.get(), isLeft, isFirst, page);
1622     matchPageRules(m_authorStyle.get(), isLeft, isFirst, page);
1623     m_lineHeightValue = 0;
1624     applyDeclarations<true>(false, 0, m_matchedDecls.size() - 1);
1625
1626     // If our font got dirtied, go ahead and update it now.
1627     if (m_fontDirty)
1628         updateFont();
1629
1630     // Line-height is set when we are sure we decided on the font-size
1631     if (m_lineHeightValue)
1632         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
1633
1634     applyDeclarations<false>(false, 0, m_matchedDecls.size() - 1);
1635
1636     // Start loading images referenced by this style.
1637     loadPendingImages();
1638
1639     // Now return the style.
1640     return m_style.release();
1641 }
1642
1643 #if ENABLE(DATAGRID)
1644
1645 PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForDataGridColumn(DataGridColumn*, RenderStyle*)
1646 {
1647     // FIXME: Implement
1648     return 0;
1649 }
1650
1651 PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForDataGridColumnHeader(DataGridColumn*, RenderStyle*)
1652 {
1653     // FIXME: Implement
1654     return 0;
1655 }
1656
1657 #endif
1658
1659 static void addIntrinsicMargins(RenderStyle* style)
1660 {
1661     // Intrinsic margin value.
1662     const int intrinsicMargin = 2 * style->effectiveZoom();
1663     
1664     // FIXME: Using width/height alone and not also dealing with min-width/max-width is flawed.
1665     // FIXME: Using "quirk" to decide the margin wasn't set is kind of lame.
1666     if (style->width().isIntrinsicOrAuto()) {
1667         if (style->marginLeft().quirk())
1668             style->setMarginLeft(Length(intrinsicMargin, Fixed));
1669         if (style->marginRight().quirk())
1670             style->setMarginRight(Length(intrinsicMargin, Fixed));
1671     }
1672
1673     if (style->height().isAuto()) {
1674         if (style->marginTop().quirk())
1675             style->setMarginTop(Length(intrinsicMargin, Fixed));
1676         if (style->marginBottom().quirk())
1677             style->setMarginBottom(Length(intrinsicMargin, Fixed));
1678     }
1679 }
1680
1681 void CSSStyleSelector::adjustRenderStyle(RenderStyle* style, RenderStyle* parentStyle, Element *e)
1682 {
1683     // Cache our original display.
1684     style->setOriginalDisplay(style->display());
1685
1686     if (style->display() != NONE) {
1687         // If we have a <td> that specifies a float property, in quirks mode we just drop the float
1688         // property.
1689         // Sites also commonly use display:inline/block on <td>s and <table>s.  In quirks mode we force
1690         // these tags to retain their display types.
1691         if (!m_checker.m_strictParsing && e) {
1692             if (e->hasTagName(tdTag)) {
1693                 style->setDisplay(TABLE_CELL);
1694                 style->setFloating(FNONE);
1695             }
1696             else if (e->hasTagName(tableTag))
1697                 style->setDisplay(style->isDisplayInlineType() ? INLINE_TABLE : TABLE);
1698         }
1699
1700         if (e && (e->hasTagName(tdTag) || e->hasTagName(thTag))) {
1701             if (style->whiteSpace() == KHTML_NOWRAP) {
1702                 // Figure out if we are really nowrapping or if we should just
1703                 // use normal instead.  If the width of the cell is fixed, then
1704                 // we don't actually use NOWRAP.
1705                 if (style->width().isFixed())
1706                     style->setWhiteSpace(NORMAL);
1707                 else
1708                     style->setWhiteSpace(NOWRAP);
1709             }
1710         }
1711
1712         // Tables never support the -webkit-* values for text-align and will reset back to the default.
1713         if (e && e->hasTagName(tableTag) && (style->textAlign() == WEBKIT_LEFT || style->textAlign() == WEBKIT_CENTER || style->textAlign() == WEBKIT_RIGHT))
1714             style->setTextAlign(TAAUTO);
1715
1716         // Frames and framesets never honor position:relative or position:absolute.  This is necessary to
1717         // fix a crash where a site tries to position these objects.  They also never honor display.
1718         if (e && (e->hasTagName(frameTag) || e->hasTagName(framesetTag))) {
1719             style->setPosition(StaticPosition);
1720             style->setDisplay(BLOCK);
1721         }
1722
1723         // Table headers with a text-align of auto will change the text-align to center.
1724         if (e && e->hasTagName(thTag) && style->textAlign() == TAAUTO)
1725             style->setTextAlign(CENTER);
1726
1727         if (e && e->hasTagName(legendTag))
1728             style->setDisplay(BLOCK);
1729
1730         // Mutate the display to BLOCK or TABLE for certain cases, e.g., if someone attempts to
1731         // position or float an inline, compact, or run-in.  Cache the original display, since it
1732         // may be needed for positioned elements that have to compute their static normal flow
1733         // positions.  We also force inline-level roots to be block-level.
1734         if (style->display() != BLOCK && style->display() != TABLE && style->display() != BOX &&
1735             (style->position() == AbsolutePosition || style->position() == FixedPosition || style->floating() != FNONE ||
1736              (e && e->document()->documentElement() == e))) {
1737             if (style->display() == INLINE_TABLE)
1738                 style->setDisplay(TABLE);
1739             else if (style->display() == INLINE_BOX)
1740                 style->setDisplay(BOX);
1741             else if (style->display() == LIST_ITEM) {
1742                 // It is a WinIE bug that floated list items lose their bullets, so we'll emulate the quirk,
1743                 // but only in quirks mode.
1744                 if (!m_checker.m_strictParsing && style->floating() != FNONE)
1745                     style->setDisplay(BLOCK);
1746             }
1747             else
1748                 style->setDisplay(BLOCK);
1749         }
1750         
1751         // FIXME: Don't support this mutation for pseudo styles like first-letter or first-line, since it's not completely
1752         // clear how that should work.
1753         if (style->display() == INLINE && style->styleType() == NOPSEUDO && parentStyle && style->writingMode() != parentStyle->writingMode())
1754             style->setDisplay(INLINE_BLOCK);
1755         
1756         // After performing the display mutation, check table rows.  We do not honor position:relative on
1757         // table rows or cells.  This has been established in CSS2.1 (and caused a crash in containingBlock()
1758         // on some sites).
1759         if ((style->display() == TABLE_HEADER_GROUP || style->display() == TABLE_ROW_GROUP ||
1760              style->display() == TABLE_FOOTER_GROUP || style->display() == TABLE_ROW || style->display() == TABLE_CELL) &&
1761              style->position() == RelativePosition)
1762             style->setPosition(StaticPosition);
1763
1764         // writing-mode does not apply to table row groups, table column groups, table rows, and table columns.
1765         // FIXME: Table cells should be allowed to be perpendicular or flipped with respect to the table, though.
1766         if (style->display() == TABLE_COLUMN || style->display() == TABLE_COLUMN_GROUP || style->display() == TABLE_FOOTER_GROUP
1767             || style->display() == TABLE_HEADER_GROUP || style->display() == TABLE_ROW || style->display() == TABLE_ROW_GROUP
1768             || style->display() == TABLE_CELL)
1769             style->setWritingMode(parentStyle->writingMode());
1770
1771         // FIXME: Since we don't support block-flow on flexible boxes yet, disallow setting
1772         // of block-flow to anything other than TopToBottomWritingMode.
1773         // https://bugs.webkit.org/show_bug.cgi?id=46418 - Flexible box support.
1774         if (style->writingMode() != TopToBottomWritingMode && (style->display() == BOX || style->display() == INLINE_BOX))
1775             style->setWritingMode(TopToBottomWritingMode);
1776     }
1777
1778     // Make sure our z-index value is only applied if the object is positioned.
1779     if (style->position() == StaticPosition)
1780         style->setHasAutoZIndex();
1781
1782     // Auto z-index becomes 0 for the root element and transparent objects.  This prevents
1783     // cases where objects that should be blended as a single unit end up with a non-transparent
1784     // object wedged in between them.  Auto z-index also becomes 0 for objects that specify transforms/masks/reflections.
1785     if (style->hasAutoZIndex() && ((e && e->document()->documentElement() == e) || style->opacity() < 1.0f || 
1786         style->hasTransformRelatedProperty() || style->hasMask() || style->boxReflect()))
1787         style->setZIndex(0);
1788     
1789 #if ENABLE(WML)
1790     if (e && (e->hasTagName(WMLNames::insertedLegendTag)
1791               || e->hasTagName(WMLNames::inputTag))
1792             && style->width().isAuto())
1793         style->setWidth(Length(Intrinsic));
1794 #endif
1795
1796     // Textarea considers overflow visible as auto.
1797     if (e && e->hasTagName(textareaTag)) {
1798         style->setOverflowX(style->overflowX() == OVISIBLE ? OAUTO : style->overflowX());
1799         style->setOverflowY(style->overflowY() == OVISIBLE ? OAUTO : style->overflowY());
1800     }
1801
1802     // Finally update our text decorations in effect, but don't allow text-decoration to percolate through
1803     // tables, inline blocks, inline tables, or run-ins.
1804     if (style->display() == TABLE || style->display() == INLINE_TABLE || style->display() == RUN_IN
1805         || style->display() == INLINE_BLOCK || style->display() == INLINE_BOX)
1806         style->setTextDecorationsInEffect(style->textDecoration());
1807     else
1808         style->addToTextDecorationsInEffect(style->textDecoration());
1809     
1810     // If either overflow value is not visible, change to auto.
1811     if (style->overflowX() == OMARQUEE && style->overflowY() != OMARQUEE)
1812         style->setOverflowY(OMARQUEE);
1813     else if (style->overflowY() == OMARQUEE && style->overflowX() != OMARQUEE)
1814         style->setOverflowX(OMARQUEE);
1815     else if (style->overflowX() == OVISIBLE && style->overflowY() != OVISIBLE)
1816         style->setOverflowX(OAUTO);
1817     else if (style->overflowY() == OVISIBLE && style->overflowX() != OVISIBLE)
1818         style->setOverflowY(OAUTO);
1819
1820     // Table rows, sections and the table itself will support overflow:hidden and will ignore scroll/auto.
1821     // FIXME: Eventually table sections will support auto and scroll.
1822     if (style->display() == TABLE || style->display() == INLINE_TABLE ||
1823         style->display() == TABLE_ROW_GROUP || style->display() == TABLE_ROW) {
1824         if (style->overflowX() != OVISIBLE && style->overflowX() != OHIDDEN) 
1825             style->setOverflowX(OVISIBLE);
1826         if (style->overflowY() != OVISIBLE && style->overflowY() != OHIDDEN) 
1827             style->setOverflowY(OVISIBLE);
1828     }
1829
1830     // Menulists should have visible overflow
1831     if (style->appearance() == MenulistPart) {
1832         style->setOverflowX(OVISIBLE);
1833         style->setOverflowY(OVISIBLE);
1834     }
1835
1836     // Cull out any useless layers and also repeat patterns into additional layers.
1837     style->adjustBackgroundLayers();
1838     style->adjustMaskLayers();
1839
1840     // Do the same for animations and transitions.
1841     style->adjustAnimations();
1842     style->adjustTransitions();
1843
1844     // Important: Intrinsic margins get added to controls before the theme has adjusted the style, since the theme will
1845     // alter fonts and heights/widths.
1846     if (e && e->isFormControlElement() && style->fontSize() >= 11) {
1847         // Don't apply intrinsic margins to image buttons.  The designer knows how big the images are,
1848         // so we have to treat all image buttons as though they were explicitly sized.
1849         if (!e->hasTagName(inputTag) || !static_cast<HTMLInputElement*>(e)->isImageButton())
1850             addIntrinsicMargins(style);
1851     }
1852
1853     // Let the theme also have a crack at adjusting the style.
1854     if (style->hasAppearance())
1855         RenderTheme::defaultTheme()->adjustStyle(this, style, e, m_hasUAAppearance, m_borderData, m_backgroundData, m_backgroundColor);
1856
1857 #if ENABLE(SVG)
1858     if (e && e->isSVGElement()) {
1859         // Spec: http://www.w3.org/TR/SVG/masking.html#OverflowProperty
1860         if (style->overflowY() == OSCROLL)
1861             style->setOverflowY(OHIDDEN);
1862         else if (style->overflowY() == OAUTO)
1863             style->setOverflowY(OVISIBLE);
1864
1865         if (style->overflowX() == OSCROLL)
1866             style->setOverflowX(OHIDDEN);
1867         else if (style->overflowX() == OAUTO)
1868             style->setOverflowX(OVISIBLE);
1869
1870         // Only the root <svg> element in an SVG document fragment tree honors css position
1871         if (!(e->hasTagName(SVGNames::svgTag) && e->parentNode() && !e->parentNode()->isSVGElement()))
1872             style->setPosition(RenderStyle::initialPosition());
1873     }
1874 #endif
1875 }
1876
1877 void CSSStyleSelector::updateFont()
1878 {
1879     checkForTextSizeAdjust();
1880     checkForGenericFamilyChange(style(), m_parentStyle);
1881     checkForZoomChange(style(), m_parentStyle);
1882     m_style->font().update(m_fontSelector);
1883     m_fontDirty = false;
1884 }
1885
1886 void CSSStyleSelector::cacheBorderAndBackground()
1887 {
1888     m_hasUAAppearance = m_style->hasAppearance();
1889     if (m_hasUAAppearance) {
1890         m_borderData = m_style->border();
1891         m_backgroundData = *m_style->backgroundLayers();
1892         m_backgroundColor = m_style->backgroundColor();
1893     }
1894 }
1895
1896 PassRefPtr<CSSRuleList> CSSStyleSelector::styleRulesForElement(Element* e, bool authorOnly, bool includeEmptyRules, CSSRuleFilter filter)
1897 {
1898     return pseudoStyleRulesForElement(e, NOPSEUDO, authorOnly, includeEmptyRules, filter);
1899 }
1900
1901 PassRefPtr<CSSRuleList> CSSStyleSelector::pseudoStyleRulesForElement(Element* e, PseudoId pseudoId, bool authorOnly, bool includeEmptyRules, CSSRuleFilter filter)
1902 {
1903     if (!e || !e->document()->haveStylesheetsLoaded())
1904         return 0;
1905
1906     m_checker.m_collectRulesOnly = true;
1907
1908     initElement(e);
1909     initForStyleResolve(e, 0, pseudoId);
1910
1911     if (!authorOnly) {
1912         int firstUARule = -1, lastUARule = -1;
1913         // First we match rules from the user agent sheet.
1914         matchUARules(firstUARule, lastUARule);
1915
1916         // Now we check user sheet rules.
1917         if (m_matchAuthorAndUserStyles) {
1918             int firstUserRule = -1, lastUserRule = -1;
1919             matchRules(m_userStyle.get(), firstUserRule, lastUserRule, includeEmptyRules);
1920         }
1921     }
1922
1923     if (m_matchAuthorAndUserStyles) {
1924         m_checker.m_sameOriginOnly = (filter == SameOriginCSSRulesOnly);
1925
1926         // Check the rules in author sheets.
1927         int firstAuthorRule = -1, lastAuthorRule = -1;
1928         matchRules(m_authorStyle.get(), firstAuthorRule, lastAuthorRule, includeEmptyRules);
1929
1930         m_checker.m_sameOriginOnly = false;
1931     }
1932
1933     m_checker.m_collectRulesOnly = false;
1934    
1935     return m_ruleList.release();
1936 }
1937
1938 bool CSSStyleSelector::checkSelector(CSSSelector* sel)
1939 {
1940     m_dynamicPseudo = NOPSEUDO;
1941
1942     // Check the selector
1943     SelectorMatch match = m_checker.checkSelector(sel, m_element, &m_selectorAttrs, m_dynamicPseudo, false, false, style(), m_parentNode ? m_parentNode->renderStyle() : 0);
1944     if (match != SelectorMatches)
1945         return false;
1946
1947     if (m_checker.m_pseudoStyle != NOPSEUDO && m_checker.m_pseudoStyle != m_dynamicPseudo)
1948         return false;
1949
1950     return true;
1951 }
1952
1953 // Recursive check of selectors and combinators
1954 // It can return 3 different values:
1955 // * SelectorMatches         - the selector matches the element e
1956 // * SelectorFailsLocally    - the selector fails for the element e
1957 // * SelectorFailsCompletely - the selector fails for e and any sibling or ancestor of e
1958 CSSStyleSelector::SelectorMatch CSSStyleSelector::SelectorChecker::checkSelector(CSSSelector* sel, Element* e, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, bool encounteredLink, RenderStyle* elementStyle, RenderStyle* elementParentStyle) const
1959 {
1960 #if ENABLE(SVG)
1961     // Spec: CSS2 selectors cannot be applied to the (conceptually) cloned DOM tree
1962     // because its contents are not part of the formal document structure.
1963     if (e->isSVGElement() && e->isShadowNode())
1964         return SelectorFailsCompletely;
1965 #endif
1966
1967     // first selector has to match
1968     if (!checkOneSelector(sel, e, selectorAttrs, dynamicPseudo, isSubSelector, elementStyle, elementParentStyle))
1969         return SelectorFailsLocally;
1970
1971     // The rest of the selectors has to match
1972     CSSSelector::Relation relation = sel->relation();
1973
1974     // Prepare next sel
1975     sel = sel->tagHistory();
1976     if (!sel)
1977         return SelectorMatches;
1978
1979     if (relation != CSSSelector::SubSelector)
1980         // Bail-out if this selector is irrelevant for the pseudoStyle
1981         if (m_pseudoStyle != NOPSEUDO && m_pseudoStyle != dynamicPseudo)
1982             return SelectorFailsCompletely;
1983
1984     // Check for nested links.
1985     if (m_matchVisitedPseudoClass && !isSubSelector) {
1986         RenderStyle* currentStyle = elementStyle ? elementStyle : e->renderStyle();
1987         if (currentStyle && currentStyle->insideLink() && e->isLink()) {
1988             if (encounteredLink)
1989                 m_matchVisitedPseudoClass = false; // This link is not relevant to the style being resolved, so disable matching.
1990             else
1991                 encounteredLink = true;
1992         }
1993     }
1994
1995     switch (relation) {
1996         case CSSSelector::Descendant:
1997             while (true) {
1998                 ContainerNode* n = e->parentNode();
1999                 if (!n || !n->isElementNode())
2000                     return SelectorFailsCompletely;
2001                 e = static_cast<Element*>(n);
2002                 SelectorMatch match = checkSelector(sel, e, selectorAttrs, dynamicPseudo, false, encounteredLink);
2003                 if (match != SelectorFailsLocally)
2004                     return match;
2005             }
2006             break;
2007         case CSSSelector::Child:
2008         {
2009             ContainerNode* n = e->parentNode();
2010             if (!n || !n->isElementNode())
2011                 return SelectorFailsCompletely;
2012             e = static_cast<Element*>(n);
2013             return checkSelector(sel, e, selectorAttrs, dynamicPseudo, false, encounteredLink);
2014         }
2015         case CSSSelector::DirectAdjacent:
2016         {
2017             if (!m_collectRulesOnly && e->parentNode() && e->parentNode()->isElementNode()) {
2018                 RenderStyle* parentStyle = elementStyle ? elementParentStyle : e->parentNode()->renderStyle();
2019                 if (parentStyle)
2020                     parentStyle->setChildrenAffectedByDirectAdjacentRules();
2021             }
2022             Node* n = e->previousSibling();
2023             while (n && !n->isElementNode())
2024                 n = n->previousSibling();
2025             if (!n)
2026                 return SelectorFailsLocally;
2027             e = static_cast<Element*>(n);
2028             m_matchVisitedPseudoClass = false;
2029             return checkSelector(sel, e, selectorAttrs, dynamicPseudo, false, encounteredLink); 
2030         }
2031         case CSSSelector::IndirectAdjacent:
2032             if (!m_collectRulesOnly && e->parentNode() && e->parentNode()->isElementNode()) {
2033                 RenderStyle* parentStyle = elementStyle ? elementParentStyle : e->parentNode()->renderStyle();
2034                 if (parentStyle)
2035                     parentStyle->setChildrenAffectedByForwardPositionalRules();
2036             }
2037             while (true) {
2038                 Node* n = e->previousSibling();
2039                 while (n && !n->isElementNode())
2040                     n = n->previousSibling();
2041                 if (!n)
2042                     return SelectorFailsLocally;
2043                 e = static_cast<Element*>(n);
2044                 m_matchVisitedPseudoClass = false;
2045                 SelectorMatch match = checkSelector(sel, e, selectorAttrs, dynamicPseudo, false, encounteredLink);
2046                 if (match != SelectorFailsLocally)
2047                     return match;
2048             };
2049             break;
2050         case CSSSelector::SubSelector:
2051             // a selector is invalid if something follows a pseudo-element
2052             // We make an exception for scrollbar pseudo elements and allow a set of pseudo classes (but nothing else)
2053             // to follow the pseudo elements.
2054             if ((elementStyle || m_collectRulesOnly) && dynamicPseudo != NOPSEUDO && dynamicPseudo != SELECTION &&
2055                 !((RenderScrollbar::scrollbarForStyleResolve() || dynamicPseudo == SCROLLBAR_CORNER || dynamicPseudo == RESIZER) && sel->m_match == CSSSelector::PseudoClass))
2056                 return SelectorFailsCompletely;
2057             return checkSelector(sel, e, selectorAttrs, dynamicPseudo, true, encounteredLink, elementStyle, elementParentStyle);
2058     }
2059
2060     return SelectorFailsCompletely;
2061 }
2062
2063 static void addLocalNameToSet(HashSet<AtomicStringImpl*>* set, const QualifiedName& qName)
2064 {
2065     set->add(qName.localName().impl());
2066 }
2067
2068 static HashSet<AtomicStringImpl*>* createHtmlCaseInsensitiveAttributesSet()
2069 {
2070     // This is the list of attributes in HTML 4.01 with values marked as "[CI]" or case-insensitive
2071     // Mozilla treats all other values as case-sensitive, thus so do we.
2072     HashSet<AtomicStringImpl*>* attrSet = new HashSet<AtomicStringImpl*>;
2073
2074     addLocalNameToSet(attrSet, accept_charsetAttr);
2075     addLocalNameToSet(attrSet, acceptAttr);
2076     addLocalNameToSet(attrSet, alignAttr);
2077     addLocalNameToSet(attrSet, alinkAttr);
2078     addLocalNameToSet(attrSet, axisAttr);
2079     addLocalNameToSet(attrSet, bgcolorAttr);
2080     addLocalNameToSet(attrSet, charsetAttr);
2081     addLocalNameToSet(attrSet, checkedAttr);
2082     addLocalNameToSet(attrSet, clearAttr);
2083     addLocalNameToSet(attrSet, codetypeAttr);
2084     addLocalNameToSet(attrSet, colorAttr);
2085     addLocalNameToSet(attrSet, compactAttr);
2086     addLocalNameToSet(attrSet, declareAttr);
2087     addLocalNameToSet(attrSet, deferAttr);
2088     addLocalNameToSet(attrSet, dirAttr);
2089     addLocalNameToSet(attrSet, disabledAttr);
2090     addLocalNameToSet(attrSet, enctypeAttr);
2091     addLocalNameToSet(attrSet, faceAttr);
2092     addLocalNameToSet(attrSet, frameAttr);
2093     addLocalNameToSet(attrSet, hreflangAttr);
2094     addLocalNameToSet(attrSet, http_equivAttr);
2095     addLocalNameToSet(attrSet, langAttr);
2096     addLocalNameToSet(attrSet, languageAttr);
2097     addLocalNameToSet(attrSet, linkAttr);
2098     addLocalNameToSet(attrSet, mediaAttr);
2099     addLocalNameToSet(attrSet, methodAttr);
2100     addLocalNameToSet(attrSet, multipleAttr);
2101     addLocalNameToSet(attrSet, nohrefAttr);
2102     addLocalNameToSet(attrSet, noresizeAttr);
2103     addLocalNameToSet(attrSet, noshadeAttr);
2104     addLocalNameToSet(attrSet, nowrapAttr);
2105     addLocalNameToSet(attrSet, readonlyAttr);
2106     addLocalNameToSet(attrSet, relAttr);
2107     addLocalNameToSet(attrSet, revAttr);
2108     addLocalNameToSet(attrSet, rulesAttr);
2109     addLocalNameToSet(attrSet, scopeAttr);
2110     addLocalNameToSet(attrSet, scrollingAttr);
2111     addLocalNameToSet(attrSet, selectedAttr);
2112     addLocalNameToSet(attrSet, shapeAttr);
2113     addLocalNameToSet(attrSet, targetAttr);
2114     addLocalNameToSet(attrSet, textAttr);
2115     addLocalNameToSet(attrSet, typeAttr);
2116     addLocalNameToSet(attrSet, valignAttr);
2117     addLocalNameToSet(attrSet, valuetypeAttr);
2118     addLocalNameToSet(attrSet, vlinkAttr);
2119
2120     return attrSet;
2121 }
2122
2123 static bool htmlAttributeHasCaseInsensitiveValue(const QualifiedName& attr)
2124 {
2125     static HashSet<AtomicStringImpl*>* htmlCaseInsensitiveAttributesSet = createHtmlCaseInsensitiveAttributesSet();
2126     bool isPossibleHTMLAttr = !attr.hasPrefix() && (attr.namespaceURI() == nullAtom);
2127     return isPossibleHTMLAttr && htmlCaseInsensitiveAttributesSet->contains(attr.localName().impl());
2128 }
2129
2130 bool CSSStyleSelector::SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, RenderStyle* elementStyle, RenderStyle* elementParentStyle) const
2131 {
2132     if (!e)
2133         return false;
2134
2135     if (sel->hasTag()) {
2136         const AtomicString& selLocalName = sel->m_tag.localName();
2137         if (selLocalName != starAtom && selLocalName != e->localName())
2138             return false;
2139         const AtomicString& selNS = sel->m_tag.namespaceURI();
2140         if (selNS != starAtom && selNS != e->namespaceURI())
2141             return false;
2142     }
2143
2144     if (sel->hasAttribute()) {
2145         if (sel->m_match == CSSSelector::Class)
2146             return e->hasClass() && static_cast<StyledElement*>(e)->classNames().contains(sel->m_value);
2147
2148         if (sel->m_match == CSSSelector::Id)
2149             return e->hasID() && e->idForStyleResolution() == sel->m_value;
2150         
2151         const QualifiedName& attr = sel->attribute();
2152
2153         // FIXME: Handle the case were elementStyle is 0.
2154         if (elementStyle && (!e->isStyledElement() || (!static_cast<StyledElement*>(e)->isMappedAttribute(attr) && attr != typeAttr && attr != readonlyAttr))) {
2155             elementStyle->setAffectedByAttributeSelectors(); // Special-case the "type" and "readonly" attributes so input form controls can share style.
2156             if (selectorAttrs)
2157                 selectorAttrs->add(attr.localName().impl());
2158         }
2159
2160         const AtomicString& value = e->getAttribute(attr);
2161         if (value.isNull())
2162             return false; // attribute is not set
2163
2164         bool caseSensitive = !m_documentIsHTML || !htmlAttributeHasCaseInsensitiveValue(attr);
2165
2166         switch (sel->m_match) {
2167         case CSSSelector::Exact:
2168             if (caseSensitive ? sel->m_value != value : !equalIgnoringCase(sel->m_value, value))
2169                 return false;
2170             break;
2171         case CSSSelector::List:
2172         {
2173             // Ignore empty selectors or selectors containing spaces
2174             if (sel->m_value.contains(' ') || sel->m_value.isEmpty())
2175                 return false;
2176
2177             unsigned startSearchAt = 0;
2178             while (true) {
2179                 size_t foundPos = value.find(sel->m_value, startSearchAt, caseSensitive);
2180                 if (foundPos == notFound)
2181                     return false;
2182                 if (foundPos == 0 || value[foundPos - 1] == ' ') {
2183                     unsigned endStr = foundPos + sel->m_value.length();
2184                     if (endStr == value.length() || value[endStr] == ' ')
2185                         break; // We found a match.
2186                 }
2187                 
2188                 // No match. Keep looking.
2189                 startSearchAt = foundPos + 1;
2190             }
2191             break;
2192         }
2193         case CSSSelector::Contain:
2194             if (!value.contains(sel->m_value, caseSensitive) || sel->m_value.isEmpty())
2195                 return false;
2196             break;
2197         case CSSSelector::Begin:
2198             if (!value.startsWith(sel->m_value, caseSensitive) || sel->m_value.isEmpty())
2199                 return false;
2200             break;
2201         case CSSSelector::End:
2202             if (!value.endsWith(sel->m_value, caseSensitive) || sel->m_value.isEmpty())
2203                 return false;
2204             break;
2205         case CSSSelector::Hyphen:
2206             if (value.length() < sel->m_value.length())
2207                 return false;
2208             if (!value.startsWith(sel->m_value, caseSensitive))
2209                 return false;
2210             // It they start the same, check for exact match or following '-':
2211             if (value.length() != sel->m_value.length() && value[sel->m_value.length()] != '-')
2212                 return false;
2213             break;
2214         case CSSSelector::PseudoClass:
2215         case CSSSelector::PseudoElement:
2216         default:
2217             break;
2218         }
2219     }
2220     
2221     if (sel->m_match == CSSSelector::PseudoClass) {
2222         // Handle :not up front.
2223         if (sel->pseudoType() == CSSSelector::PseudoNot) {
2224             // check the simple selector
2225             for (CSSSelector* subSel = sel->simpleSelector(); subSel; subSel = subSel->tagHistory()) {
2226                 // :not cannot nest. I don't really know why this is a
2227                 // restriction in CSS3, but it is, so let's honor it.
2228                 // the parser enforces that this never occurs
2229                 ASSERT(!subSel->simpleSelector());
2230
2231                 if (!checkOneSelector(subSel, e, selectorAttrs, dynamicPseudo, true, elementStyle, elementParentStyle))
2232                     return true;
2233             }
2234         } else if (dynamicPseudo != NOPSEUDO && (RenderScrollbar::scrollbarForStyleResolve() || dynamicPseudo == SCROLLBAR_CORNER || dynamicPseudo == RESIZER)) {
2235             // CSS scrollbars match a specific subset of pseudo classes, and they have specialized rules for each
2236             // (since there are no elements involved).
2237             return checkScrollbarPseudoClass(sel, dynamicPseudo);
2238         } else if (dynamicPseudo == SELECTION) {
2239             if (sel->pseudoType() == CSSSelector::PseudoWindowInactive)
2240                 return !m_document->page()->focusController()->isActive();
2241         }
2242         
2243         // Normal element pseudo class checking.
2244         switch (sel->pseudoType()) {
2245             // Pseudo classes:
2246             case CSSSelector::PseudoNot:
2247                 break; // Already handled up above.
2248             case CSSSelector::PseudoEmpty: {
2249                 bool result = true;
2250                 for (Node* n = e->firstChild(); n; n = n->nextSibling()) {
2251                     if (n->isElementNode()) {
2252                         result = false;
2253                         break;
2254                     } else if (n->isTextNode()) {
2255                         Text* textNode = static_cast<Text*>(n);
2256                         if (!textNode->data().isEmpty()) {
2257                             result = false;
2258                             break;
2259                         }
2260                     }
2261                 }
2262                 if (!m_collectRulesOnly) {
2263                     if (elementStyle)
2264                         elementStyle->setEmptyState(result);
2265                     else if (e->renderStyle() && (e->document()->usesSiblingRules() || e->renderStyle()->unique()))
2266                         e->renderStyle()->setEmptyState(result);
2267                 }
2268                 return result;
2269             }
2270             case CSSSelector::PseudoFirstChild: {
2271                 // first-child matches the first child that is an element
2272                 if (e->parentNode() && e->parentNode()->isElementNode()) {
2273                     bool result = false;
2274                     Node* n = e->previousSibling();
2275                     while (n && !n->isElementNode())
2276                         n = n->previousSibling();
2277                     if (!n)
2278                         result = true;
2279                     if (!m_collectRulesOnly) {
2280                         RenderStyle* childStyle = elementStyle ? elementStyle : e->renderStyle();
2281                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : e->parentNode()->renderStyle();
2282                         if (parentStyle)
2283                             parentStyle->setChildrenAffectedByFirstChildRules();
2284                         if (result && childStyle)
2285                             childStyle->setFirstChildState();
2286                     }
2287                     return result;
2288                 }
2289                 break;
2290             }
2291             case CSSSelector::PseudoFirstOfType: {
2292                 // first-of-type matches the first element of its type
2293                 if (e->parentNode() && e->parentNode()->isElementNode()) {
2294                     bool result = false;
2295                     const QualifiedName& type = e->tagQName();
2296                     Node* n = e->previousSibling();
2297                     while (n) {
2298                         if (n->isElementNode() && static_cast<Element*>(n)->hasTagName(type))
2299                             break;
2300                         n = n->previousSibling();
2301                     }
2302                     if (!n)
2303                         result = true;
2304                     if (!m_collectRulesOnly) {
2305                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : e->parentNode()->renderStyle();
2306                         if (parentStyle)
2307                             parentStyle->setChildrenAffectedByForwardPositionalRules();
2308                     }
2309                     return result;
2310                 }
2311                 break;
2312             }
2313             case CSSSelector::PseudoLastChild: {
2314                 // last-child matches the last child that is an element
2315                 if (Element* parentElement = e->parentElement()) {
2316                     bool result = false;
2317                     if (parentElement->isFinishedParsingChildren()) {
2318                         Node* n = e->nextSibling();
2319                         while (n && !n->isElementNode())
2320                             n = n->nextSibling();
2321                         if (!n)
2322                             result = true;
2323                     }
2324                     if (!m_collectRulesOnly) {
2325                         RenderStyle* childStyle = elementStyle ? elementStyle : e->renderStyle();
2326                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
2327                         if (parentStyle)
2328                             parentStyle->setChildrenAffectedByLastChildRules();
2329                         if (result && childStyle)
2330                             childStyle->setLastChildState();
2331                     }
2332                     return result;
2333                 }
2334                 break;
2335             }
2336             case CSSSelector::PseudoLastOfType: {
2337                 // last-of-type matches the last element of its type
2338                 if (Element* parentElement = e->parentElement()) {
2339                     if (!m_collectRulesOnly) {
2340                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
2341                         if (parentStyle)
2342                             parentStyle->setChildrenAffectedByBackwardPositionalRules();
2343                     }
2344                     if (!parentElement->isFinishedParsingChildren())
2345                         return false;
2346                     bool result = false;
2347                     const QualifiedName& type = e->tagQName();
2348                     Node* n = e->nextSibling();
2349                     while (n) {
2350                         if (n->isElementNode() && static_cast<Element*>(n)->hasTagName(type))
2351                             break;
2352                         n = n->nextSibling();
2353                     }
2354                     if (!n)
2355                         result = true;
2356                     return result;
2357                 }
2358                 break;
2359             }
2360             case CSSSelector::PseudoOnlyChild: {
2361                 if (Element* parentElement = e->parentElement()) {
2362                     bool firstChild = false;
2363                     bool lastChild = false;
2364                     
2365                     Node* n = e->previousSibling();
2366                     while (n && !n->isElementNode())
2367                         n = n->previousSibling();
2368                     if (!n)
2369                         firstChild = true;
2370                     if (firstChild && parentElement->isFinishedParsingChildren()) {
2371                         n = e->nextSibling();
2372                         while (n && !n->isElementNode())
2373                             n = n->nextSibling();
2374                         if (!n)
2375                             lastChild = true;
2376                     }
2377                     if (!m_collectRulesOnly) {
2378                         RenderStyle* childStyle = elementStyle ? elementStyle : e->renderStyle();
2379                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
2380                         if (parentStyle) {
2381                             parentStyle->setChildrenAffectedByFirstChildRules();
2382                             parentStyle->setChildrenAffectedByLastChildRules();
2383                         }
2384                         if (firstChild && childStyle)
2385                             childStyle->setFirstChildState();
2386                         if (lastChild && childStyle)
2387                             childStyle->setLastChildState();
2388                     }
2389                     return firstChild && lastChild;
2390                 }
2391                 break;
2392             }
2393             case CSSSelector::PseudoOnlyOfType: {
2394                 // FIXME: This selector is very slow.
2395                 if (Element* parentElement = e->parentElement()) {
2396                     if (!m_collectRulesOnly) {
2397                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
2398                         if (parentStyle) {
2399                             parentStyle->setChildrenAffectedByForwardPositionalRules();
2400                             parentStyle->setChildrenAffectedByBackwardPositionalRules();
2401                         }
2402                     }
2403                     if (!parentElement->isFinishedParsingChildren())
2404                         return false;
2405                     bool firstChild = false;
2406                     bool lastChild = false;
2407                     const QualifiedName& type = e->tagQName();
2408                     Node* n = e->previousSibling();
2409                     while (n) {
2410                         if (n->isElementNode() && static_cast<Element*>(n)->hasTagName(type))
2411                             break;
2412                         n = n->previousSibling();
2413                     }
2414                     if (!n)
2415                         firstChild = true;
2416                     if (firstChild) {
2417                         n = e->nextSibling();
2418                         while (n) {
2419                             if (n->isElementNode() && static_cast<Element*>(n)->hasTagName(type))
2420                                 break;
2421                             n = n->nextSibling();
2422                         }
2423                         if (!n)
2424                             lastChild = true;
2425                     }
2426                     return firstChild && lastChild;
2427                 }
2428                 break;
2429             }
2430             case CSSSelector::PseudoNthChild: {
2431                 if (!sel->parseNth())
2432                     break;
2433                 if (Element* parentElement = e->parentElement()) {
2434                     int count = 1;
2435                     Node* n = e->previousSibling();
2436                     while (n) {
2437                         if (n->isElementNode()) {
2438                             RenderStyle* s = n->renderStyle();
2439                             unsigned index = s ? s->childIndex() : 0;
2440                             if (index) {
2441                                 count += index;
2442                                 break;
2443                             }
2444                             count++;
2445                         }
2446                         n = n->previousSibling();
2447                     }
2448                     
2449                     if (!m_collectRulesOnly) {
2450                         RenderStyle* childStyle = elementStyle ? elementStyle : e->renderStyle();
2451                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
2452                         if (childStyle)
2453                             childStyle->setChildIndex(count);
2454                         if (parentStyle)
2455                             parentStyle->setChildrenAffectedByForwardPositionalRules();
2456                     }
2457                     
2458                     if (sel->matchNth(count))
2459                         return true;
2460                 }
2461                 break;
2462             }
2463             case CSSSelector::PseudoNthOfType: {
2464                 if (!sel->parseNth())
2465                     break;
2466                 if (Element* parentElement = e->parentElement()) {
2467                     int count = 1;
2468                     const QualifiedName& type = e->tagQName();
2469                     Node* n = e->previousSibling();
2470                     while (n) {
2471                         if (n->isElementNode() && static_cast<Element*>(n)->hasTagName(type))
2472                             count++;
2473                         n = n->previousSibling();
2474                     }
2475                     
2476                     if (!m_collectRulesOnly) {
2477                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
2478                         if (parentStyle)
2479                             parentStyle->setChildrenAffectedByForwardPositionalRules();
2480                     }
2481
2482                     if (sel->matchNth(count))
2483                         return true;
2484                 }
2485                 break;
2486             }
2487             case CSSSelector::PseudoNthLastChild: {
2488                 if (!sel->parseNth())
2489                     break;
2490                 if (Element* parentElement = e->parentElement()) {
2491                     if (!m_collectRulesOnly) {
2492                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
2493                         if (parentStyle)
2494                             parentStyle->setChildrenAffectedByBackwardPositionalRules();
2495                     }
2496                     if (!parentElement->isFinishedParsingChildren())
2497                         return false;
2498                     int count = 1;
2499                     Node* n = e->nextSibling();
2500                     while (n) {
2501                         if (n->isElementNode())
2502                             count++;
2503                         n = n->nextSibling();
2504                     }
2505                     if (sel->matchNth(count))
2506                         return true;
2507                 }
2508                 break;
2509             }
2510             case CSSSelector::PseudoNthLastOfType: {
2511                 if (!sel->parseNth())
2512                     break;
2513                 if (Element* parentElement = e->parentElement()) {
2514                     if (!m_collectRulesOnly) {
2515                         RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
2516                         if (parentStyle)
2517                             parentStyle->setChildrenAffectedByBackwardPositionalRules();
2518                     }
2519                     if (!parentElement->isFinishedParsingChildren())
2520                         return false;
2521                     int count = 1;
2522                     const QualifiedName& type = e->tagQName();
2523                     Node* n = e->nextSibling();
2524                     while (n) {
2525                         if (n->isElementNode() && static_cast<Element*>(n)->hasTagName(type))
2526                             count++;
2527                         n = n->nextSibling();
2528                     }
2529                     if (sel->matchNth(count))
2530                         return true;
2531                 }
2532                 break;
2533             }
2534             case CSSSelector::PseudoTarget:
2535                 if (e == e->document()->cssTarget())
2536                     return true;
2537                 break;
2538             case CSSSelector::PseudoAnyLink:
2539                 if (e && e->isLink())
2540                     return true;
2541                 break;
2542             case CSSSelector::PseudoAutofill: {
2543                 if (!e || !e->isFormControlElement())
2544                     break;
2545                 if (InputElement* inputElement = toInputElement(e))
2546                     return inputElement->isAutofilled();
2547                 break;
2548             }
2549             case CSSSelector::PseudoLink:
2550                 if (e && e->isLink())
2551                     return !m_matchVisitedPseudoClass;
2552                 break;
2553             case CSSSelector::PseudoVisited:
2554                 if (e && e->isLink())
2555                     return m_matchVisitedPseudoClass;
2556                 break;
2557             case CSSSelector::PseudoDrag: {
2558                 if (elementStyle)
2559                     elementStyle->setAffectedByDragRules(true);
2560                 else if (e->renderStyle())
2561                     e->renderStyle()->setAffectedByDragRules(true);
2562                 if (e->renderer() && e->renderer()->isDragging())
2563                     return true;
2564                 break;
2565             }
2566             case CSSSelector::PseudoFocus:
2567                 if (e && e->focused() && e->document()->frame() && e->document()->frame()->selection()->isFocusedAndActive())
2568                     return true;
2569                 break;
2570             case CSSSelector::PseudoHover: {
2571                 // If we're in quirks mode, then hover should never match anchors with no
2572                 // href and *:hover should not match anything.  This is important for sites like wsj.com.
2573                 if (m_strictParsing || isSubSelector || (sel->hasTag() && !e->hasTagName(aTag)) || e->isLink()) {
2574                     if (elementStyle)
2575                         elementStyle->setAffectedByHoverRules(true);
2576                     else if (e->renderStyle())
2577                         e->renderStyle()->setAffectedByHoverRules(true);
2578                     if (e->hovered())
2579                         return true;
2580                 }
2581                 break;
2582             }
2583             case CSSSelector::PseudoActive:
2584                 // If we're in quirks mode, then :active should never match anchors with no
2585                 // href and *:active should not match anything. 
2586                 if (m_strictParsing || isSubSelector || (sel->hasTag() && !e->hasTagName(aTag)) || e->isLink()) {
2587                     if (elementStyle)
2588                         elementStyle->setAffectedByActiveRules(true);
2589                     else if (e->renderStyle())
2590                         e->renderStyle()->setAffectedByActiveRules(true);
2591                     if (e->active())
2592                         return true;
2593                 }
2594                 break;
2595             case CSSSelector::PseudoEnabled:
2596                 if (e && e->isFormControlElement())
2597                     return e->isEnabledFormControl();
2598                 break;
2599             case CSSSelector::PseudoFullPageMedia:
2600                 return e && e->document() && e->document()->isMediaDocument();
2601                 break;
2602             case CSSSelector::PseudoDefault:
2603                 return e && e->isDefaultButtonForForm();
2604             case CSSSelector::PseudoDisabled:
2605                 if (e && e->isFormControlElement())
2606                     return !e->isEnabledFormControl();
2607                 break;
2608             case CSSSelector::PseudoReadOnly: {
2609                 if (!e || !e->isFormControlElement())
2610                     return false;
2611                 return e->isTextFormControl() && e->isReadOnlyFormControl();
2612             }
2613             case CSSSelector::PseudoReadWrite: {
2614                 if (!e || !e->isFormControlElement())
2615                     return false;
2616                 return e->isTextFormControl() && !e->isReadOnlyFormControl();
2617             }
2618             case CSSSelector::PseudoOptional:
2619                 return e && e->isOptionalFormControl();
2620             case CSSSelector::PseudoRequired:
2621                 return e && e->isRequiredFormControl();
2622             case CSSSelector::PseudoValid: {
2623                 if (!e)
2624                     return false;
2625                 e->document()->setContainsValidityStyleRules();
2626                 return e->willValidate() && e->isValidFormControlElement();
2627             } case CSSSelector::PseudoInvalid: {
2628                 if (!e)
2629                     return false;
2630                 e->document()->setContainsValidityStyleRules();
2631                 return (e->willValidate() && !e->isValidFormControlElement()) || e->hasUnacceptableValue();
2632             } case CSSSelector::PseudoChecked: {
2633                 if (!e || !e->isFormControlElement())
2634                     break;
2635                 // Even though WinIE allows checked and indeterminate to co-exist, the CSS selector spec says that
2636                 // you can't be both checked and indeterminate.  We will behave like WinIE behind the scenes and just
2637                 // obey the CSS spec here in the test for matching the pseudo.
2638                 InputElement* inputElement = toInputElement(e);
2639                 if (inputElement && inputElement->isChecked() && !inputElement->isIndeterminate())
2640                     return true;
2641                 break;
2642             }
2643             case CSSSelector::PseudoIndeterminate: {
2644                 if (!e || !e->isFormControlElement())
2645                     break;
2646                 InputElement* inputElement = toInputElement(e);
2647                 if (inputElement && inputElement->isIndeterminate())
2648                     return true;
2649                 break;
2650             }
2651             case CSSSelector::PseudoRoot:
2652                 if (e == e->document()->documentElement())
2653                     return true;
2654                 break;
2655             case CSSSelector::PseudoLang: {
2656                 AtomicString value = e->computeInheritedLanguage();
2657                 const AtomicString& argument = sel->argument();
2658                 if (value.isEmpty() || !value.startsWith(argument, false))
2659                     break;
2660                 if (value.length() != argument.length() && value[argument.length()] != '-')
2661                     break;
2662                 return true;
2663             }
2664 #if ENABLE(FULLSCREEN_API)
2665             case CSSSelector::PseudoFullScreen:
2666                 // While a Document is in the fullscreen state, and the document's current fullscreen 
2667                 // element is an element in the document, the 'full-screen' pseudoclass applies to 
2668                 // that element. Also, an <iframe>, <object> or <embed> element whose child browsing 
2669                 // context's Document is in the fullscreen state has the 'full-screen' pseudoclass applied.
2670                 if (!e->document()->webkitFullScreen())
2671                     return false;
2672                 if (e != e->document()->webkitCurrentFullScreenElement())
2673                     return false;
2674                 return true;
2675             case CSSSelector::PseudoFullScreenDocument:
2676                 // While a Document is in the fullscreen state, the 'full-screen-document' pseudoclass applies 
2677                 // to the root element of that Document.
2678                 if (!e->document()->webkitFullScreen())
2679                     return false;
2680                 if (e != e->document()->documentElement())
2681                     return false;
2682                 return true;
2683 #endif
2684             case CSSSelector::PseudoUnknown:
2685             case CSSSelector::PseudoNotParsed:
2686             default:
2687                 ASSERT_NOT_REACHED();
2688                 break;
2689         }
2690         return false;
2691     }
2692     if (sel->m_match == CSSSelector::PseudoElement) {
2693         if (!elementStyle && !m_collectRulesOnly)
2694             return false;
2695
2696         PseudoId pseudoId = CSSSelector::pseudoId(sel->pseudoType());
2697         if (pseudoId == FIRST_LETTER) {
2698             if (Document* document = e->document())
2699                 document->setUsesFirstLetterRules(true);
2700         }
2701         if (pseudoId != NOPSEUDO) {
2702             dynamicPseudo = pseudoId;
2703             return true;
2704         }
2705         ASSERT_NOT_REACHED();
2706         return false;
2707     }
2708     // ### add the rest of the checks...
2709     return true;
2710 }
2711
2712 bool CSSStyleSelector::SelectorChecker::checkScrollbarPseudoClass(CSSSelector* sel, PseudoId&) const
2713 {
2714     RenderScrollbar* scrollbar = RenderScrollbar::scrollbarForStyleResolve();
2715     ScrollbarPart part = RenderScrollbar::partForStyleResolve();
2716
2717     // FIXME: This is a temporary hack for resizers and scrollbar corners.  Eventually :window-inactive should become a real
2718     // pseudo class and just apply to everything.
2719     if (sel->pseudoType() == CSSSelector::PseudoWindowInactive)
2720         return !m_document->page()->focusController()->isActive();
2721     
2722     if (!scrollbar)
2723         return false;
2724         
2725     ASSERT(sel->m_match == CSSSelector::PseudoClass);
2726     switch (sel->pseudoType()) {
2727         case CSSSelector::PseudoEnabled:
2728             return scrollbar->enabled();
2729         case CSSSelector::PseudoDisabled:
2730             return !scrollbar->enabled();
2731         case CSSSelector::PseudoHover: {
2732             ScrollbarPart hoveredPart = scrollbar->hoveredPart();
2733             if (part == ScrollbarBGPart)
2734                 return hoveredPart != NoPart;
2735             if (part == TrackBGPart)
2736                 return hoveredPart == BackTrackPart || hoveredPart == ForwardTrackPart || hoveredPart == ThumbPart;
2737             return part == hoveredPart;
2738         }
2739         case CSSSelector::PseudoActive: {
2740             ScrollbarPart pressedPart = scrollbar->pressedPart();
2741             if (part == ScrollbarBGPart)
2742                 return pressedPart != NoPart;
2743             if (part == TrackBGPart)
2744                 return pressedPart == BackTrackPart || pressedPart == ForwardTrackPart || pressedPart == ThumbPart;
2745             return part == pressedPart;
2746         }
2747         case CSSSelector::PseudoHorizontal:
2748             return scrollbar->orientation() == HorizontalScrollbar;
2749         case CSSSelector::PseudoVertical:
2750             return scrollbar->orientation() == VerticalScrollbar;
2751         case CSSSelector::PseudoDecrement:
2752             return part == BackButtonStartPart || part == BackButtonEndPart || part == BackTrackPart;
2753         case CSSSelector::PseudoIncrement:
2754             return part == ForwardButtonStartPart || part == ForwardButtonEndPart || part == ForwardTrackPart;
2755         case CSSSelector::PseudoStart:
2756             return part == BackButtonStartPart || part == ForwardButtonStartPart || part == BackTrackPart;
2757         case CSSSelector::PseudoEnd:
2758             return part == BackButtonEndPart || part == ForwardButtonEndPart || part == ForwardTrackPart;
2759         case CSSSelector::PseudoDoubleButton: {
2760             ScrollbarButtonsPlacement buttonsPlacement = scrollbar->theme()->buttonsPlacement();
2761             if (part == BackButtonStartPart || part == ForwardButtonStartPart || part == BackTrackPart)
2762                 return buttonsPlacement == ScrollbarButtonsDoubleStart || buttonsPlacement == ScrollbarButtonsDoubleBoth;
2763             if (part == BackButtonEndPart || part == ForwardButtonEndPart || part == ForwardTrackPart)
2764                 return buttonsPlacement == ScrollbarButtonsDoubleEnd || buttonsPlacement == ScrollbarButtonsDoubleBoth;
2765             return false;
2766         } 
2767         case CSSSelector::PseudoSingleButton: {
2768             ScrollbarButtonsPlacement buttonsPlacement = scrollbar->theme()->buttonsPlacement();
2769             if (part == BackButtonStartPart || part == ForwardButtonEndPart || part == BackTrackPart || part == ForwardTrackPart)
2770                 return buttonsPlacement == ScrollbarButtonsSingle;
2771             return false;
2772         }
2773         case CSSSelector::PseudoNoButton: {
2774             ScrollbarButtonsPlacement buttonsPlacement = scrollbar->theme()->buttonsPlacement();
2775             if (part == BackTrackPart)
2776                 return buttonsPlacement == ScrollbarButtonsNone || buttonsPlacement == ScrollbarButtonsDoubleEnd;
2777             if (part == ForwardTrackPart)
2778                 return buttonsPlacement == ScrollbarButtonsNone || buttonsPlacement == ScrollbarButtonsDoubleStart;
2779             return false;
2780         }
2781         case CSSSelector::PseudoCornerPresent:
2782             return scrollbar->client()->scrollbarCornerPresent();
2783         default:
2784             return false;
2785     }
2786 }
2787
2788 void CSSStyleSelector::addVariables(CSSVariablesRule* variables)
2789 {
2790     CSSVariablesDeclaration* decl = variables->variables();
2791     if (!decl)
2792         return;
2793     unsigned size = decl->length();
2794     for (unsigned i = 0; i < size; ++i) {
2795         String name = decl->item(i);
2796         m_variablesMap.set(name, variables);
2797     }
2798 }
2799
2800 CSSValue* CSSStyleSelector::resolveVariableDependentValue(CSSVariableDependentValue*)
2801 {
2802     return 0;
2803 }
2804
2805 // -----------------------------------------------------------------
2806
2807 CSSRuleSet::CSSRuleSet()
2808     : m_ruleCount(0)
2809     , m_pageRuleCount(0)
2810 {
2811 }
2812
2813 CSSRuleSet::~CSSRuleSet()
2814
2815     deleteAllValues(m_idRules);
2816     deleteAllValues(m_classRules);
2817     deleteAllValues(m_tagRules);
2818 }
2819
2820
2821 void CSSRuleSet::addToRuleSet(AtomicStringImpl* key, AtomRuleMap& map,
2822                               CSSStyleRule* rule, CSSSelector* sel)
2823 {
2824     if (!key) return;
2825     CSSRuleDataList* rules = map.get(key);
2826     if (!rules) {
2827         rules = new CSSRuleDataList(m_ruleCount++, rule, sel);
2828         map.set(key, rules);
2829     } else
2830         rules->append(m_ruleCount++, rule, sel);
2831 }
2832
2833 void CSSRuleSet::addRule(CSSStyleRule* rule, CSSSelector* sel)
2834 {
2835     if (sel->m_match == CSSSelector::Id) {
2836         addToRuleSet(sel->m_value.impl(), m_idRules, rule, sel);
2837         return;
2838     }
2839     if (sel->m_match == CSSSelector::Class) {
2840         addToRuleSet(sel->m_value.impl(), m_classRules, rule, sel);
2841         return;
2842     }
2843      
2844     const AtomicString& localName = sel->m_tag.localName();
2845     if (localName != starAtom) {
2846         addToRuleSet(localName.impl(), m_tagRules, rule, sel);
2847         return;
2848     }
2849     
2850     // Just put it in the universal rule set.
2851     if (!m_universalRules)
2852         m_universalRules = adoptPtr(new CSSRuleDataList(m_ruleCount++, rule, sel));
2853     else
2854         m_universalRules->append(m_ruleCount++, rule, sel);
2855 }
2856
2857 void CSSRuleSet::addPageRule(CSSStyleRule* rule, CSSSelector* sel)
2858 {
2859     if (!m_pageRules)
2860         m_pageRules = adoptPtr(new CSSRuleDataList(m_pageRuleCount++, rule, sel));
2861     else
2862         m_pageRules->append(m_pageRuleCount++, rule, sel);
2863 }
2864
2865 void CSSRuleSet::addRulesFromSheet(CSSStyleSheet* sheet, const MediaQueryEvaluator& medium, CSSStyleSelector* styleSelector)
2866 {
2867     if (!sheet)
2868         return;
2869
2870     // No media implies "all", but if a media list exists it must
2871     // contain our current medium
2872     if (sheet->media() && !medium.eval(sheet->media(), styleSelector))
2873         return; // the style sheet doesn't apply
2874
2875     int len = sheet->length();
2876
2877     for (int i = 0; i < len; i++) {
2878         StyleBase* item = sheet->item(i);
2879         if (item->isStyleRule()) {
2880             addStyleRule(item);
2881         }
2882         else if (item->isImportRule()) {
2883             CSSImportRule* import = static_cast<CSSImportRule*>(item);
2884             if (!import->media() || medium.eval(import->media(), styleSelector))
2885                 addRulesFromSheet(import->styleSheet(), medium, styleSelector);
2886         }
2887         else if (item->isMediaRule()) {
2888             CSSMediaRule* r = static_cast<CSSMediaRule*>(item);
2889             CSSRuleList* rules = r->cssRules();
2890
2891             if ((!r->media() || medium.eval(r->media(), styleSelector)) && rules) {
2892                 // Traverse child elements of the @media rule.
2893                 for (unsigned j = 0; j < rules->length(); j++) {
2894                     CSSRule *childItem = rules->item(j);
2895                     if (childItem->isStyleRule()) {
2896                         // It is a StyleRule, so append it to our list
2897                         addStyleRule(childItem);
2898                     } else if (childItem->isFontFaceRule() && styleSelector) {
2899                         // Add this font face to our set.
2900                         const CSSFontFaceRule* fontFaceRule = static_cast<CSSFontFaceRule*>(childItem);
2901                         styleSelector->fontSelector()->addFontFaceRule(fontFaceRule);
2902                     } else if (childItem->isKeyframesRule() && styleSelector) {
2903                         // Add this keyframe rule to our set.
2904                         styleSelector->addKeyframeStyle(static_cast<WebKitCSSKeyframesRule*>(childItem));
2905                     }
2906                 }   // for rules
2907             }   // if rules
2908         } else if (item->isFontFaceRule() && styleSelector) {
2909             // Add this font face to our set.
2910             const CSSFontFaceRule* fontFaceRule = static_cast<CSSFontFaceRule*>(item);
2911             styleSelector->fontSelector()->addFontFaceRule(fontFaceRule);
2912         } else if (item->isVariablesRule()) {
2913             // Evaluate the media query and make sure it matches.
2914             CSSVariablesRule* variables = static_cast<CSSVariablesRule*>(item);
2915             if (!variables->media() || medium.eval(variables->media(), styleSelector))
2916                 styleSelector->addVariables(variables);
2917         } else if (item->isKeyframesRule())
2918             styleSelector->addKeyframeStyle(static_cast<WebKitCSSKeyframesRule*>(item));
2919     }
2920 }
2921
2922 void CSSRuleSet::addStyleRule(StyleBase* item)
2923 {
2924     if (item->isPageRule()) {
2925         CSSPageRule* pageRule = static_cast<CSSPageRule*>(item);
2926         addPageRule(pageRule, pageRule->selectorList().first());
2927     } else {
2928         CSSStyleRule* rule = static_cast<CSSStyleRule*>(item);
2929         for (CSSSelector* s = rule->selectorList().first(); s; s = CSSSelectorList::next(s))
2930             addRule(rule, s);
2931     }
2932 }
2933
2934 // -------------------------------------------------------------------------------------
2935 // this is mostly boring stuff on how to apply a certain rule to the renderstyle...
2936
2937 static Length convertToLength(CSSPrimitiveValue* primitiveValue, RenderStyle* style, RenderStyle* rootStyle, double multiplier = 1, bool *ok = 0)
2938 {
2939     // This function is tolerant of a null style value. The only place style is used is in
2940     // length measurements, like 'ems' and 'px'. And in those cases style is only used
2941     // when the units are EMS or EXS. So we will just fail in those cases.
2942     Length l;
2943     if (!primitiveValue) {
2944         if (ok)
2945             *ok = false;
2946     } else {
2947         int type = primitiveValue->primitiveType();
2948         
2949         if (!style && (type == CSSPrimitiveValue::CSS_EMS || type == CSSPrimitiveValue::CSS_EXS || type == CSSPrimitiveValue::CSS_REMS)) {
2950             if (ok)
2951                 *ok = false;
2952         } else if (CSSPrimitiveValue::isUnitTypeLength(type))
2953             l = Length(primitiveValue->computeLengthIntForLength(style, rootStyle, multiplier), Fixed);
2954         else if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
2955             l = Length(primitiveValue->getDoubleValue(), Percent);
2956         else if (type == CSSPrimitiveValue::CSS_NUMBER)
2957             l = Length(primitiveValue->getDoubleValue() * 100.0, Percent);
2958         else if (ok)
2959             *ok = false;
2960     }
2961     return l;
2962 }
2963
2964 template <bool applyFirst>
2965 void CSSStyleSelector::applyDeclarations(bool isImportant, int startIndex, int endIndex)
2966 {
2967     if (startIndex == -1)
2968         return;
2969
2970     for (int i = startIndex; i <= endIndex; i++) {
2971         CSSMutableStyleDeclaration* decl = m_matchedDecls[i];
2972         CSSMutableStyleDeclaration::const_iterator end = decl->end();
2973         for (CSSMutableStyleDeclaration::const_iterator it = decl->begin(); it != end; ++it) {
2974             const CSSProperty& current = *it;
2975             if (isImportant == current.isImportant()) {
2976                 int property = current.id();
2977
2978                 if (applyFirst) {
2979                     COMPILE_ASSERT(firstCSSProperty == CSSPropertyColor, CSS_color_is_first_property);
2980                     COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 13, CSS_zoom_is_end_of_first_prop_range);
2981                     COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyZoom + 1, CSS_line_height_is_after_zoom);
2982
2983                     // give special priority to font-xxx, color properties, etc
2984                     if (property <= CSSPropertyLineHeight) {
2985                         // we apply line-height later
2986                         if (property == CSSPropertyLineHeight)
2987                             m_lineHeightValue = current.value(); 
2988                         else 
2989                             applyProperty(current.id(), current.value());
2990                     }
2991                 } else {
2992                     if (property > CSSPropertyLineHeight)
2993                         applyProperty(current.id(), current.value());
2994                 }
2995             }
2996         }
2997     }
2998 }
2999
3000 void CSSStyleSelector::matchPageRules(CSSRuleSet* rules, bool isLeftPage, bool isFirstPage, const String& pageName)
3001 {
3002     m_matchedRules.clear();
3003
3004     if (!rules)
3005         return;
3006
3007     matchPageRulesForList(rules->getPageRules(), isLeftPage, isFirstPage, pageName);
3008
3009     // If we didn't match any rules, we're done.
3010     if (m_matchedRules.isEmpty())
3011         return;
3012
3013     // Sort the set of matched rules.
3014     sortMatchedRules(0, m_matchedRules.size());
3015
3016     // Now transfer the set of matched rules over to our list of decls.
3017     for (unsigned i = 0; i < m_matchedRules.size(); i++)
3018         addMatchedDeclaration(m_matchedRules[i]->rule()->declaration());
3019 }
3020
3021 void CSSStyleSelector::matchPageRulesForList(CSSRuleDataList* rules, bool isLeftPage, bool isFirstPage, const String& pageName)
3022 {
3023     if (!rules)
3024         return;
3025
3026     for (CSSRuleData* d = rules->first(); d; d = d->next()) {
3027         CSSStyleRule* rule = d->rule();
3028         const AtomicString& selectorLocalName = d->selector()->m_tag.localName();
3029         if (selectorLocalName != starAtom && selectorLocalName != pageName)
3030             continue;
3031         CSSSelector::PseudoType pseudoType = d->selector()->pseudoType();
3032         if ((pseudoType == CSSSelector::PseudoLeftPage && !isLeftPage)
3033             || (pseudoType == CSSSelector::PseudoRightPage && isLeftPage)
3034             || (pseudoType == CSSSelector::PseudoFirstPage && !isFirstPage))
3035             continue;
3036
3037         // If the rule has no properties to apply, then ignore it.
3038         CSSMutableStyleDeclaration* decl = rule->declaration();
3039         if (!decl || !decl->length())
3040             continue;
3041
3042         // Add this rule to our list of matched rules.
3043         addMatchedRule(d);
3044     }
3045 }
3046
3047 bool CSSStyleSelector::isLeftPage(int pageIndex) const
3048 {
3049     bool isFirstPageLeft = false;
3050     if (!m_rootElementStyle->isLeftToRightDirection())
3051         isFirstPageLeft = true;
3052
3053     return (pageIndex + (isFirstPageLeft ? 1 : 0)) % 2;
3054 }
3055
3056 bool CSSStyleSelector::isFirstPage(int pageIndex) const
3057 {
3058     // FIXME: In case of forced left/right page, page at index 1 (not 0) can be the first page.
3059     return (!pageIndex);
3060 }
3061
3062 String CSSStyleSelector::pageName(int /* pageIndex */) const
3063 {
3064     // FIXME: Implement page index to page name mapping.
3065     return "";
3066 }
3067
3068 static void applyCounterList(RenderStyle* style, CSSValueList* list, bool isReset)
3069 {
3070     CounterDirectiveMap& map = style->accessCounterDirectives();
3071     typedef CounterDirectiveMap::iterator Iterator;
3072
3073     Iterator end = map.end();
3074     for (Iterator it = map.begin(); it != end; ++it)
3075         if (isReset)
3076             it->second.m_reset = false;
3077         else
3078             it->second.m_increment = false;
3079
3080     int length = list ? list->length() : 0;
3081     for (int i = 0; i < length; ++i) {
3082         Pair* pair = static_cast<CSSPrimitiveValue*>(list->itemWithoutBoundsCheck(i))->getPairValue();
3083         AtomicString identifier = static_cast<CSSPrimitiveValue*>(pair->first())->getStringValue();
3084         // FIXME: What about overflow?
3085         int value = static_cast<CSSPrimitiveValue*>(pair->second())->getIntValue();
3086         CounterDirectives& directives = map.add(identifier.impl(), CounterDirectives()).first->second;
3087         if (isReset) {
3088             directives.m_reset = true;
3089             directives.m_resetValue = value;
3090         } else {
3091             if (directives.m_increment)
3092                 directives.m_incrementValue += value;
3093             else {
3094                 directives.m_increment = true;
3095                 directives.m_incrementValue = value;
3096             }
3097         }
3098     }
3099 }
3100
3101 void CSSStyleSelector::applyPropertyToStyle(int id, CSSValue *value, RenderStyle* style)
3102 {
3103     initElement(0);
3104     initForStyleResolve(0, style);
3105     m_style = style;
3106     if (value)
3107         applyProperty(id, value);
3108 }
3109
3110 inline bool isValidVisitedLinkProperty(int id)
3111 {
3112     switch(static_cast<CSSPropertyID>(id)) {
3113         case CSSPropertyBackgroundColor:
3114         case CSSPropertyBorderLeftColor:
3115         case CSSPropertyBorderRightColor:
3116         case CSSPropertyBorderTopColor:
3117         case CSSPropertyBorderBottomColor:
3118         case CSSPropertyColor:
3119         case CSSPropertyOutlineColor:
3120         case CSSPropertyWebkitColumnRuleColor:
3121         case CSSPropertyWebkitTextFillColor:
3122         case CSSPropertyWebkitTextStrokeColor:
3123         // Also allow shorthands so that inherit/initial still work.
3124         case CSSPropertyBackground:
3125         case CSSPropertyBorderLeft:
3126         case CSSPropertyBorderRight:
3127         case CSSPropertyBorderTop:
3128         case CSSPropertyBorderBottom:
3129         case CSSPropertyOutline:
3130         case CSSPropertyWebkitColumnRule:
3131 #if ENABLE(SVG)
3132         case CSSPropertyFill:
3133         case CSSPropertyStroke:
3134 #endif
3135             return true;
3136         default:
3137             break;
3138     }
3139
3140     return false;
3141 }
3142
3143 void CSSStyleSelector::applyProperty(int id, CSSValue *value)
3144 {
3145     CSSPrimitiveValue* primitiveValue = 0;
3146     if (value->isPrimitiveValue())
3147         primitiveValue = static_cast<CSSPrimitiveValue*>(value);
3148
3149     float zoomFactor = m_style->effectiveZoom();
3150
3151     // SVG handles zooming in a different way compared to CSS. The whole document is scaled instead
3152     // of each individual length value in the render style / tree. CSSPrimitiveValue::computeLength*()
3153     // multiplies each resolved length with the zoom multiplier - so for SVG we need to disable that.
3154     // Though all CSS values that can be applied to outermost <svg> elements (width/height/border/padding...)
3155     // need to respect the scaling. RenderBox (the parent class of RenderSVGRoot) grabs values like
3156     // width/height/border/padding/... from the RenderStyle -> for SVG these values would never scale,
3157     // if we'd pass a 1.0 zoom factor everyhwere. So we only pass a zoom factor of 1.0 for specific
3158     // properties that are NOT allowed to scale within a zoomed SVG document (letter/word-spacing/font-size).
3159     bool useSVGZoomRules = m_element && m_element->isSVGElement();
3160
3161     Length l;
3162     bool apply = false;
3163
3164     unsigned short valueType = value->cssValueType();
3165
3166     bool isInherit = m_parentNode && valueType == CSSValue::CSS_INHERIT;
3167     bool isInitial = valueType == CSSValue::CSS_INITIAL || (!m_parentNode && valueType == CSSValue::CSS_INHERIT);
3168     
3169     id = CSSProperty::resolveDirectionAwareProperty(id, m_style->direction(), m_style->writingMode());
3170
3171     if (m_checker.m_matchVisitedPseudoClass && !isValidVisitedLinkProperty(id)) {
3172         // Limit the properties that can be applied to only the ones honored by :visited.
3173         return;
3174     }
3175     
3176     // What follows is a list that maps the CSS properties into their corresponding front-end
3177     // RenderStyle values.  Shorthands (e.g. border, background) occur in this list as well and
3178     // are only hit when mapping "inherit" or "initial" into front-end values.
3179     CSSPropertyID property = static_cast<CSSPropertyID>(id);
3180     switch (property) {
3181 // ident only properties
3182     case CSSPropertyBackgroundAttachment:
3183         HANDLE_BACKGROUND_VALUE(attachment, Attachment, value)
3184         return;
3185     case CSSPropertyBackgroundClip:
3186     case CSSPropertyWebkitBackgroundClip:
3187         HANDLE_BACKGROUND_VALUE(clip, Clip, value)
3188         return;
3189     case CSSPropertyWebkitBackgroundComposite:
3190         HANDLE_BACKGROUND_VALUE(composite, Composite, value)
3191         return;
3192     case CSSPropertyBackgroundOrigin:
3193     case CSSPropertyWebkitBackgroundOrigin:
3194         HANDLE_BACKGROUND_VALUE(origin, Origin, value)
3195         return;
3196     case CSSPropertyBackgroundSize:
3197     case CSSPropertyWebkitBackgroundSize:
3198         HANDLE_BACKGROUND_VALUE(size, Size, value)
3199         return;
3200     case CSSPropertyWebkitMaskAttachment:
3201         HANDLE_MASK_VALUE(attachment, Attachment, value)
3202         return;
3203     case CSSPropertyWebkitMaskClip:
3204         HANDLE_MASK_VALUE(clip, Clip, value)
3205         return;
3206     case CSSPropertyWebkitMaskComposite:
3207         HANDLE_MASK_VALUE(composite, Composite, value)
3208         return;
3209     case CSSPropertyWebkitMaskOrigin:
3210         HANDLE_MASK_VALUE(origin, Origin, value)
3211         return;
3212     case CSSPropertyWebkitMaskSize:
3213         HANDLE_MASK_VALUE(size, Size, value)
3214         return;
3215     case CSSPropertyBorderCollapse:
3216         HANDLE_INHERIT_AND_INITIAL(borderCollapse, BorderCollapse)
3217         if (!primitiveValue)
3218             return;
3219         switch (primitiveValue->getIdent()) {
3220             case CSSValueCollapse:
3221                 m_style->setBorderCollapse(true);
3222                 break;
3223             case CSSValueSeparate:
3224                 m_style->setBorderCollapse(false);
3225                 break;
3226             default:
3227                 return;
3228         }
3229         return;
3230     case CSSPropertyBorderTopStyle:
3231         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE_WITH_VALUE(borderTopStyle, BorderTopStyle, BorderStyle)
3232         return;
3233     case CSSPropertyBorderRightStyle:
3234         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE_WITH_VALUE(borderRightStyle, BorderRightStyle, BorderStyle)
3235         return;
3236     case CSSPropertyBorderBottomStyle:
3237         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE_WITH_VALUE(borderBottomStyle, BorderBottomStyle, BorderStyle)
3238         return;
3239     case CSSPropertyBorderLeftStyle:
3240         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE_WITH_VALUE(borderLeftStyle, BorderLeftStyle, BorderStyle)
3241         return;
3242     case CSSPropertyOutlineStyle:
3243         HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(outlineStyle, OutlineStyle, BorderStyle)
3244         if (primitiveValue) {
3245             if (primitiveValue->getIdent() == CSSValueAuto)
3246                 m_style->setOutlineStyle(DOTTED, true);
3247             else
3248                 m_style->setOutlineStyle(*primitiveValue);
3249         }
3250         return;
3251     case CSSPropertyCaptionSide:
3252         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(captionSide, CaptionSide)
3253         return;
3254     case CSSPropertyClear:
3255         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(clear, Clear)
3256         return;
3257     case CSSPropertyDirection:
3258         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(direction, Direction)
3259         if (!isInherit && !isInitial && m_element && m_element == m_element->document()->documentElement())
3260             m_element->document()->setDirectionSetOnDocumentElement(true);
3261         return;
3262     case CSSPropertyDisplay:
3263         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(display, Display)
3264 #if ENABLE(WCSS)
3265         if (primitiveValue) {
3266             if (primitiveValue->getIdent() == CSSValueWapMarquee) {
3267                 // Initialize WAP Marquee style
3268                 m_style->setOverflowX(OMARQUEE);
326