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