56313fe4f4b747983521d3b3a9655422bb322474
[WebKit-https.git] / Source / WebCore / css / StyleResolver.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, 2011, 2012 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  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
10  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
11  * Copyright (C) 2012 Google Inc. All rights reserved.
12  *
13  * This library is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU Library General Public
15  * License as published by the Free Software Foundation; either
16  * version 2 of the License, or (at your option) any later version.
17  *
18  * This library is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21  * Library General Public License for more details.
22  *
23  * You should have received a copy of the GNU Library General Public License
24  * along with this library; see the file COPYING.LIB.  If not, write to
25  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
26  * Boston, MA 02110-1301, USA.
27  */
28
29 #include "config.h"
30 #include "StyleResolver.h"
31
32 #include "Attribute.h"
33 #include "CSSBorderImage.h"
34 #include "CSSCalculationValue.h"
35 #include "CSSCursorImageValue.h"
36 #include "CSSFontFaceRule.h"
37 #include "CSSFontSelector.h"
38 #include "CSSImportRule.h"
39 #include "CSSLineBoxContainValue.h"
40 #include "CSSMediaRule.h"
41 #include "CSSPageRule.h"
42 #include "CSSParser.h"
43 #include "CSSPrimitiveValueMappings.h"
44 #include "CSSPropertyNames.h"
45 #include "CSSReflectValue.h"
46 #include "CSSRuleList.h"
47 #include "CSSSelector.h"
48 #include "CSSSelectorList.h"
49 #include "CSSStyleRule.h"
50 #include "CSSStyleSheet.h"
51 #include "CSSTimingFunctionValue.h"
52 #include "CSSValueList.h"
53 #if ENABLE(CSS_VARIABLES)
54 #include "CSSVariableValue.h"
55 #endif
56 #include "CachedImage.h"
57 #include "CalculationValue.h"
58 #include "ContentData.h"
59 #include "ContextFeatures.h"
60 #include "Counter.h"
61 #include "CounterContent.h"
62 #include "CursorList.h"
63 #include "FontFeatureValue.h"
64 #include "FontValue.h"
65 #include "Frame.h"
66 #include "FrameSelection.h"
67 #include "FrameView.h"
68 #include "HTMLDocument.h"
69 #include "HTMLIFrameElement.h"
70 #include "HTMLInputElement.h"
71 #include "HTMLNames.h"
72 #include "HTMLOptionElement.h"
73 #include "HTMLProgressElement.h"
74 #include "HTMLStyleElement.h"
75 #include "HTMLTextAreaElement.h"
76 #include "InspectorInstrumentation.h"
77 #include "KeyframeList.h"
78 #include "LinkHash.h"
79 #include "LocaleToScriptMapping.h"
80 #include "MathMLNames.h"
81 #include "Matrix3DTransformOperation.h"
82 #include "MatrixTransformOperation.h"
83 #include "MediaList.h"
84 #include "MediaQueryEvaluator.h"
85 #include "NodeRenderStyle.h"
86 #include "NodeRenderingContext.h"
87 #include "Page.h"
88 #include "PageGroup.h"
89 #include "Pair.h"
90 #include "PerspectiveTransformOperation.h"
91 #include "QuotesData.h"
92 #include "Rect.h"
93 #include "RenderRegion.h"
94 #include "RenderScrollbar.h"
95 #include "RenderScrollbarTheme.h"
96 #include "RenderStyleConstants.h"
97 #include "RenderTheme.h"
98 #include "RotateTransformOperation.h"
99 #include "SVGDocumentExtensions.h"
100 #include "SVGFontFaceElement.h"
101 #include "ScaleTransformOperation.h"
102 #include "SecurityOrigin.h"
103 #include "Settings.h"
104 #include "ShadowData.h"
105 #include "ShadowRoot.h"
106 #include "ShadowValue.h"
107 #include "SkewTransformOperation.h"
108 #include "StyleBuilder.h"
109 #include "StyleCachedImage.h"
110 #include "StyleGeneratedImage.h"
111 #include "StylePendingImage.h"
112 #include "StyleRule.h"
113 #include "StyleRuleImport.h"
114 #include "StyleSheetContents.h"
115 #include "StyleSheetList.h"
116 #include "Text.h"
117 #include "TransformationMatrix.h"
118 #include "TranslateTransformOperation.h"
119 #include "UserAgentStyleSheets.h"
120 #include "WebKitCSSKeyframeRule.h"
121 #include "WebKitCSSKeyframesRule.h"
122 #include "WebKitCSSRegionRule.h"
123 #include "WebKitCSSTransformValue.h"
124 #include "WebKitFontFamilyNames.h"
125 #include "XMLNames.h"
126 #include <wtf/StdLibExtras.h>
127 #include <wtf/Vector.h>
128
129 #if ENABLE(CSS_FILTERS)
130 #include "FilterOperation.h"
131 #include "WebKitCSSFilterValue.h"
132 #endif
133
134 #if ENABLE(DASHBOARD_SUPPORT)
135 #include "DashboardRegion.h"
136 #endif
137
138 #if ENABLE(SVG)
139 #include "CachedSVGDocument.h"
140 #include "SVGDocument.h"
141 #include "SVGElement.h"
142 #include "SVGNames.h"
143 #include "SVGURIReference.h"
144 #include "WebKitCSSSVGDocumentValue.h"
145 #endif
146
147 #if ENABLE(CSS_SHADERS)
148 #include "CustomFilterNumberParameter.h"
149 #include "CustomFilterOperation.h"
150 #include "CustomFilterParameter.h"
151 #include "StyleCachedShader.h"
152 #include "StyleCustomFilterProgram.h"
153 #include "StylePendingShader.h"
154 #include "StyleShader.h"
155 #include "WebKitCSSShaderValue.h"
156 #endif
157
158 #if ENABLE(CSS_IMAGE_SET)
159 #include "CSSImageSetValue.h"
160 #include "StyleCachedImageSet.h"
161 #endif
162
163 #if PLATFORM(BLACKBERRY)
164 #define FIXED_POSITION_CREATES_STACKING_CONTEXT 1
165 #endif
166
167 using namespace std;
168
169 namespace WebCore {
170
171 using namespace HTMLNames;
172
173 #define HANDLE_INHERIT(prop, Prop) \
174 if (isInherit) { \
175     m_style->set##Prop(m_parentStyle->prop()); \
176     return; \
177 }
178
179 #define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
180 HANDLE_INHERIT(prop, Prop) \
181 if (isInitial) { \
182     m_style->set##Prop(RenderStyle::initial##Prop()); \
183     return; \
184 }
185
186 #define HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(prop, Prop, Value) \
187 HANDLE_INHERIT(prop, Prop) \
188 if (isInitial) { \
189     m_style->set##Prop(RenderStyle::initial##Value());\
190     return;\
191 }
192
193 #define HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(prop, Prop) \
194 HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
195 if (primitiveValue) \
196     m_style->set##Prop(*primitiveValue);
197
198 class RuleData {
199 public:
200     RuleData(StyleRule*, CSSSelector*, unsigned position, bool hasDocumentSecurityOrigin, bool canUseFastCheckSelector, bool inRegionRule);
201
202     unsigned position() const { return m_position; }
203     StyleRule* rule() const { return m_rule; }
204     CSSSelector* selector() const { return m_selector; }
205
206     bool hasFastCheckableSelector() const { return m_hasFastCheckableSelector; }
207     bool hasMultipartSelector() const { return m_hasMultipartSelector; }
208     bool hasRightmostSelectorMatchingHTMLBasedOnRuleHash() const { return m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash; }
209     bool containsUncommonAttributeSelector() const { return m_containsUncommonAttributeSelector; }
210     unsigned specificity() const { return m_specificity; }
211     unsigned linkMatchType() const { return m_linkMatchType; }
212     bool hasDocumentSecurityOrigin() const { return m_hasDocumentSecurityOrigin; }
213     bool isInRegionRule() const { return m_isInRegionRule; }
214
215     // Try to balance between memory usage (there can be lots of RuleData objects) and good filtering performance.
216     static const unsigned maximumIdentifierCount = 4;
217     const unsigned* descendantSelectorIdentifierHashes() const { return m_descendantSelectorIdentifierHashes; }
218
219 private:
220     StyleRule* m_rule;
221     CSSSelector* m_selector;
222     unsigned m_specificity;
223     // This number was picked fairly arbitrarily. We can probably lower it if we need to.
224     // Some simple testing showed <100,000 RuleData's on large sites.
225     unsigned m_position : 24;
226     unsigned m_hasFastCheckableSelector : 1;
227     unsigned m_hasMultipartSelector : 1;
228     unsigned m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash : 1;
229     unsigned m_containsUncommonAttributeSelector : 1;
230     unsigned m_linkMatchType : 2; //  SelectorChecker::LinkMatchMask
231     unsigned m_hasDocumentSecurityOrigin : 1;
232     unsigned m_isInRegionRule : 1;
233     // Use plain array instead of a Vector to minimize memory overhead.
234     unsigned m_descendantSelectorIdentifierHashes[maximumIdentifierCount];
235 };
236     
237 struct SameSizeAsRuleData {
238     void* a;
239     void* b;
240     unsigned c;
241     unsigned d;
242     unsigned e[4];
243 };
244
245 COMPILE_ASSERT(sizeof(RuleData) == sizeof(SameSizeAsRuleData), RuleData_should_stay_small);
246
247 class RuleSet {
248     WTF_MAKE_NONCOPYABLE(RuleSet);
249 public:
250     static PassOwnPtr<RuleSet> create() { return adoptPtr(new RuleSet); }
251
252     typedef HashMap<AtomicStringImpl*, OwnPtr<Vector<RuleData> > > AtomRuleMap;
253
254     void addRulesFromSheet(StyleSheetContents*, const MediaQueryEvaluator&, StyleResolver* = 0, const ContainerNode* = 0);
255
256     void addStyleRule(StyleRule*, bool hasDocumentSecurityOrigin, bool canUseFastCheckSelector, bool isInRegionRule = false);
257     void addRule(StyleRule*, CSSSelector*, bool hasDocumentSecurityOrigin, bool canUseFastCheckSelector, bool isInRegionRule = false);
258     void addPageRule(StyleRulePage*);
259     void addToRuleSet(AtomicStringImpl* key, AtomRuleMap&, const RuleData&);
260     void addRegionRule(StyleRuleRegion*, bool hasDocumentSecurityOrigin);
261     void shrinkToFit();
262     void disableAutoShrinkToFit() { m_autoShrinkToFitEnabled = false; }
263
264     const StyleResolver::Features& features() const { return m_features; }
265
266     const Vector<RuleData>* idRules(AtomicStringImpl* key) const { return m_idRules.get(key); }
267     const Vector<RuleData>* classRules(AtomicStringImpl* key) const { return m_classRules.get(key); }
268     const Vector<RuleData>* tagRules(AtomicStringImpl* key) const { return m_tagRules.get(key); }
269     const Vector<RuleData>* shadowPseudoElementRules(AtomicStringImpl* key) const { return m_shadowPseudoElementRules.get(key); }
270     const Vector<RuleData>* linkPseudoClassRules() const { return &m_linkPseudoClassRules; }
271     const Vector<RuleData>* focusPseudoClassRules() const { return &m_focusPseudoClassRules; }
272     const Vector<RuleData>* universalRules() const { return &m_universalRules; }
273     const Vector<StyleRulePage*>& pageRules() const { return m_pageRules; }
274
275 public:
276     RuleSet();
277
278     AtomRuleMap m_idRules;
279     AtomRuleMap m_classRules;
280     AtomRuleMap m_tagRules;
281     AtomRuleMap m_shadowPseudoElementRules;
282     Vector<RuleData> m_linkPseudoClassRules;
283     Vector<RuleData> m_focusPseudoClassRules;
284     Vector<RuleData> m_universalRules;
285     Vector<StyleRulePage*> m_pageRules;
286     unsigned m_ruleCount;
287     bool m_autoShrinkToFitEnabled;
288     StyleResolver::Features m_features;
289
290     struct RuleSetSelectorPair {
291         RuleSetSelectorPair(CSSSelector* selector, PassOwnPtr<RuleSet> ruleSet) : selector(selector), ruleSet(ruleSet) { }
292         RuleSetSelectorPair(const RuleSetSelectorPair& rs) : selector(rs.selector), ruleSet(const_cast<RuleSetSelectorPair*>(&rs)->ruleSet.release()) { }
293         CSSSelector* selector;
294         OwnPtr<RuleSet> ruleSet;
295     };
296
297     Vector<RuleSetSelectorPair> m_regionSelectorsAndRuleSets;
298 };
299
300 static RuleSet* defaultStyle;
301 static RuleSet* defaultQuirksStyle;
302 static RuleSet* defaultPrintStyle;
303 static RuleSet* defaultViewSourceStyle;
304 static StyleSheetContents* simpleDefaultStyleSheet;
305 static StyleSheetContents* defaultStyleSheet;
306 static StyleSheetContents* quirksStyleSheet;
307 static StyleSheetContents* svgStyleSheet;
308 static StyleSheetContents* mathMLStyleSheet;
309 static StyleSheetContents* mediaControlsStyleSheet;
310 static StyleSheetContents* fullscreenStyleSheet;
311
312 RenderStyle* StyleResolver::s_styleNotYetAvailable;
313
314 static void loadFullDefaultStyle();
315 static void loadSimpleDefaultStyle();
316 template <class ListType>
317 static void collectCSSOMWrappers(HashMap<StyleRule*, RefPtr<CSSStyleRule> >&, ListType*);
318
319 // FIXME: It would be nice to use some mechanism that guarantees this is in sync with the real UA stylesheet.
320 static const char* simpleUserAgentStyleSheet = "html,body,div{display:block}head{display:none}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}";
321
322 static inline bool elementCanUseSimpleDefaultStyle(Element* e)
323 {
324     return e->hasTagName(htmlTag) || e->hasTagName(headTag) || e->hasTagName(bodyTag) || e->hasTagName(divTag) || e->hasTagName(spanTag) || e->hasTagName(brTag) || e->hasTagName(aTag);
325 }
326
327 static const MediaQueryEvaluator& screenEval()
328 {
329     DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticScreenEval, ("screen"));
330     return staticScreenEval;
331 }
332
333 static const MediaQueryEvaluator& printEval()
334 {
335     DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticPrintEval, ("print"));
336     return staticPrintEval;
337 }
338
339 static StylePropertySet* leftToRightDeclaration()
340 {
341     DEFINE_STATIC_LOCAL(RefPtr<StylePropertySet>, leftToRightDecl, (StylePropertySet::create()));
342     if (leftToRightDecl->isEmpty())
343         leftToRightDecl->setProperty(CSSPropertyDirection, CSSValueLtr);
344     return leftToRightDecl.get();
345 }
346
347 static StylePropertySet* rightToLeftDeclaration()
348 {
349     DEFINE_STATIC_LOCAL(RefPtr<StylePropertySet>, rightToLeftDecl, (StylePropertySet::create()));
350     if (rightToLeftDecl->isEmpty())
351         rightToLeftDecl->setProperty(CSSPropertyDirection, CSSValueRtl);
352     return rightToLeftDecl.get();
353 }
354
355 StyleResolver::StyleResolver(Document* document, bool matchAuthorAndUserStyles)
356     : m_hasUAAppearance(false)
357     , m_backgroundData(BackgroundFillLayer)
358     , m_matchedPropertiesCacheAdditionsSinceLastSweep(0)
359     , m_checker(document, !document->inQuirksMode())
360     , m_parentStyle(0)
361     , m_rootElementStyle(0)
362     , m_element(0)
363     , m_styledElement(0)
364     , m_regionForStyling(0)
365     , m_elementLinkState(NotInsideLink)
366     , m_parentNode(0)
367     , m_lineHeightValue(0)
368     , m_fontDirty(false)
369     , m_matchAuthorAndUserStyles(matchAuthorAndUserStyles)
370     , m_sameOriginOnly(false)
371     , m_fontSelector(CSSFontSelector::create(document))
372     , m_applyPropertyToRegularStyle(true)
373     , m_applyPropertyToVisitedLinkStyle(false)
374     , m_styleBuilder(StyleBuilder::sharedStyleBuilder())
375 #if ENABLE(CSS_SHADERS)
376     , m_hasPendingShaders(false)
377 #endif
378 #if ENABLE(STYLE_SCOPED)
379     , m_scopeStackParent(0)
380     , m_scopeStackParentBoundsIndex(0)
381 #endif
382     , m_styleMap(this)
383 {
384     Element* root = document->documentElement();
385
386     if (!defaultStyle) {
387         if (!root || elementCanUseSimpleDefaultStyle(root))
388             loadSimpleDefaultStyle();
389         else
390             loadFullDefaultStyle();
391     }
392
393     // construct document root element default style. this is needed
394     // to evaluate media queries that contain relative constraints, like "screen and (max-width: 10em)"
395     // This is here instead of constructor, because when constructor is run,
396     // document doesn't have documentElement
397     // NOTE: this assumes that element that gets passed to styleForElement -call
398     // is always from the document that owns the style selector
399     FrameView* view = document->view();
400     if (view)
401         m_medium = adoptPtr(new MediaQueryEvaluator(view->mediaType()));
402     else
403         m_medium = adoptPtr(new MediaQueryEvaluator("all"));
404
405     if (root)
406         m_rootDefaultStyle = styleForElement(root, 0, DisallowStyleSharing, MatchOnlyUserAgentRules);
407
408     if (m_rootDefaultStyle && view)
409         m_medium = adoptPtr(new MediaQueryEvaluator(view->mediaType(), view->frame(), m_rootDefaultStyle.get()));
410
411     m_authorStyle = RuleSet::create();
412     // Adding rules from multiple sheets, shrink at the end.
413     // Adding global rules from multiple sheets, shrink at the end.
414     // Note that there usually is only 1 sheet for scoped rules, so auto-shrink-to-fit is fine.
415     m_authorStyle->disableAutoShrinkToFit();
416
417     // FIXME: This sucks! The user sheet is reparsed every time!
418     OwnPtr<RuleSet> tempUserStyle = RuleSet::create();
419     if (CSSStyleSheet* pageUserSheet = document->pageUserSheet())
420         tempUserStyle->addRulesFromSheet(pageUserSheet->contents(), *m_medium, this);
421     addAuthorRulesAndCollectUserRulesFromSheets(document->pageGroupUserSheets(), *tempUserStyle);
422     addAuthorRulesAndCollectUserRulesFromSheets(document->documentUserSheets(), *tempUserStyle);
423     if (tempUserStyle->m_ruleCount > 0 || tempUserStyle->m_pageRules.size() > 0)
424         m_userStyle = tempUserStyle.release();
425
426 #if ENABLE(SVG_FONTS)
427     if (document->svgExtensions()) {
428         const HashSet<SVGFontFaceElement*>& svgFontFaceElements = document->svgExtensions()->svgFontFaceElements();
429         HashSet<SVGFontFaceElement*>::const_iterator end = svgFontFaceElements.end();
430         for (HashSet<SVGFontFaceElement*>::const_iterator it = svgFontFaceElements.begin(); it != end; ++it)
431             fontSelector()->addFontFaceRule((*it)->fontFaceRule());
432     }
433 #endif
434
435     addStylesheetsFromSeamlessParents();
436     appendAuthorStylesheets(0, document->styleSheets()->vector());
437 }
438
439 void StyleResolver::addStylesheetsFromSeamlessParents()
440 {
441     // Build a list of stylesheet lists from our ancestors, and walk that
442     // list in reverse order so that the root-most sheets are appended first.
443     Document* childDocument = document();
444     Vector<StyleSheetList*> ancestorSheets;
445     while (HTMLIFrameElement* parentIFrame = childDocument->seamlessParentIFrame()) {
446         Document* parentDocument = parentIFrame->document();
447         ancestorSheets.append(parentDocument->styleSheets());
448         childDocument = parentDocument;
449     }
450     for (int i = ancestorSheets.size() - 1; i >= 0; i--)
451         appendAuthorStylesheets(0, ancestorSheets.at(i)->vector());
452 }
453
454 void StyleResolver::addAuthorRulesAndCollectUserRulesFromSheets(const Vector<RefPtr<CSSStyleSheet> >* userSheets, RuleSet& userStyle)
455 {
456     if (!userSheets)
457         return;
458
459     unsigned length = userSheets->size();
460     for (unsigned i = 0; i < length; i++) {
461         StyleSheetContents* sheet = userSheets->at(i)->contents();
462         if (sheet->isUserStyleSheet())
463             userStyle.addRulesFromSheet(sheet, *m_medium, this);
464         else
465             m_authorStyle->addRulesFromSheet(sheet, *m_medium, this);
466     }
467 }
468
469 static PassOwnPtr<RuleSet> makeRuleSet(const Vector<StyleResolver::RuleFeature>& rules)
470 {
471     size_t size = rules.size();
472     if (!size)
473         return nullptr;
474     OwnPtr<RuleSet> ruleSet = RuleSet::create();
475     for (size_t i = 0; i < size; ++i)
476         ruleSet->addRule(rules[i].rule, rules[i].selector, rules[i].hasDocumentSecurityOrigin, false);
477     ruleSet->shrinkToFit();
478     return ruleSet.release();
479 }
480
481 void StyleResolver::collectFeatures()
482 {
483     m_features.clear();
484     // Collect all ids and rules using sibling selectors (:first-child and similar)
485     // in the current set of stylesheets. Style sharing code uses this information to reject
486     // sharing candidates.
487     m_features.add(defaultStyle->features());
488     m_features.add(m_authorStyle->features());
489 #if ENABLE(STYLE_SCOPED)
490     for (ScopedRuleSetMap::iterator it = m_scopedAuthorStyles.begin(); it != m_scopedAuthorStyles.end(); ++it)
491         m_features.add(it->second->features());
492 #endif
493     if (m_userStyle)
494         m_features.add(m_userStyle->features());
495
496     m_siblingRuleSet = makeRuleSet(m_features.siblingRules);
497     m_uncommonAttributeRuleSet = makeRuleSet(m_features.uncommonAttributeRules);
498 }
499
500 #if ENABLE(STYLE_SCOPED)
501 const ContainerNode* StyleResolver::determineScope(const CSSStyleSheet* sheet)
502 {
503     ASSERT(sheet);
504
505     if (!ContextFeatures::styleScopedEnabled(document()))
506         return 0;
507
508     Node* ownerNode = sheet->ownerNode();
509     if (!ownerNode || !ownerNode->isHTMLElement() || !ownerNode->hasTagName(HTMLNames::styleTag))
510         return 0;
511
512     HTMLStyleElement* styleElement = static_cast<HTMLStyleElement*>(ownerNode);
513     if (!styleElement->scoped())
514         return styleElement->isInShadowTree()? styleElement->shadowRoot() : 0;
515
516     ContainerNode* parent = styleElement->parentNode();
517     if (!parent)
518         return 0;
519
520     return (parent->isElementNode() || parent->isShadowRoot()) ? parent : 0;
521 }
522
523 inline RuleSet* StyleResolver::ruleSetForScope(const ContainerNode* scope) const
524 {
525     if (!scope->hasScopedHTMLStyleChild())
526         return 0;
527     ScopedRuleSetMap::const_iterator it = m_scopedAuthorStyles.find(scope);
528     return it != m_scopedAuthorStyles.end() ? it->second.get() : 0; 
529 }
530 #endif
531
532 void StyleResolver::appendAuthorStylesheets(unsigned firstNew, const Vector<RefPtr<StyleSheet> >& stylesheets)
533 {
534     // This handles sheets added to the end of the stylesheet list only. In other cases the style resolver
535     // needs to be reconstructed. To handle insertions too the rule order numbers would need to be updated.
536     unsigned size = stylesheets.size();
537     for (unsigned i = firstNew; i < size; ++i) {
538         if (!stylesheets[i]->isCSSStyleSheet())
539             continue;
540         CSSStyleSheet* cssSheet = static_cast<CSSStyleSheet*>(stylesheets[i].get());
541         if (cssSheet->disabled())
542             continue;
543         if (cssSheet->mediaQueries() && !m_medium->eval(cssSheet->mediaQueries(), this))
544             continue;
545         StyleSheetContents* sheet = cssSheet->contents();
546 #if ENABLE(STYLE_SCOPED)
547         const ContainerNode* scope = determineScope(cssSheet);
548         if (scope) {
549             ScopedRuleSetMap::AddResult addResult = m_scopedAuthorStyles.add(scope, nullptr);
550             if (addResult.isNewEntry)
551                 addResult.iterator->second = RuleSet::create();
552             addResult.iterator->second->addRulesFromSheet(sheet, *m_medium, this, scope);
553             continue;
554         }
555 #endif
556         m_authorStyle->addRulesFromSheet(sheet, *m_medium, this);
557         if (!m_styleRuleToCSSOMWrapperMap.isEmpty())
558             collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, cssSheet);
559     }
560     m_authorStyle->shrinkToFit();
561     collectFeatures();
562     
563     if (document()->renderer() && document()->renderer()->style())
564         document()->renderer()->style()->font().update(fontSelector());
565 }
566
567 #if ENABLE(STYLE_SCOPED)
568 void StyleResolver::setupScopeStack(const ContainerNode* parent)
569 {
570     // The scoping element stack shouldn't be used if <style scoped> isn't used anywhere.
571     ASSERT(!m_scopedAuthorStyles.isEmpty());
572
573     m_scopeStack.shrink(0);
574     int authorStyleBoundsIndex = 0;
575     for (const ContainerNode* scope = parent; scope; scope = scope->parentOrHostNode()) {
576         RuleSet* ruleSet = ruleSetForScope(scope);
577         if (ruleSet)
578             m_scopeStack.append(ScopeStackFrame(scope, authorStyleBoundsIndex, ruleSet));
579         if (scope->isShadowRoot() && !toShadowRoot(scope)->applyAuthorStyles())
580             --authorStyleBoundsIndex;
581     }
582     m_scopeStack.reverse();
583     m_scopeStackParent = parent;
584     m_scopeStackParentBoundsIndex = 0;
585 }
586
587 void StyleResolver::pushScope(const ContainerNode* scope, const ContainerNode* scopeParent)
588 {
589     // Shortcut: Don't bother with the scoping element stack if <style scoped> isn't used anywhere.
590     if (m_scopedAuthorStyles.isEmpty()) {
591         ASSERT(!m_scopeStackParent);
592         ASSERT(m_scopeStack.isEmpty());
593         return;
594     }
595     // In some wacky cases during style resolve we may get invoked for random elements.
596     // Recreate the whole scoping element stack in such cases.
597     if (!scopeStackIsConsistent(scopeParent)) {
598         setupScopeStack(scope);
599         return;
600     }
601     if (scope->isShadowRoot() && !toShadowRoot(scope)->applyAuthorStyles())
602         ++m_scopeStackParentBoundsIndex;
603     // Otherwise just push the parent onto the stack.
604     RuleSet* ruleSet = ruleSetForScope(scope);
605     if (ruleSet)
606         m_scopeStack.append(ScopeStackFrame(scope, m_scopeStackParentBoundsIndex, ruleSet));
607     m_scopeStackParent = scope;
608 }
609
610 void StyleResolver::popScope(const ContainerNode* scope)
611 {
612     // Only bother to update the scoping element stack if it is consistent.
613     if (scopeStackIsConsistent(scope)) {
614         if (!m_scopeStack.isEmpty() && m_scopeStack.last().m_scope == scope)
615             m_scopeStack.removeLast();
616         if (scope->isShadowRoot() && !toShadowRoot(scope)->applyAuthorStyles())
617             --m_scopeStackParentBoundsIndex;
618         m_scopeStackParent = scope->parentOrHostNode();
619     }
620 }
621 #endif
622
623 void StyleResolver::pushParentElement(Element* parent)
624 {
625     const ContainerNode* parentsParent = parent->parentOrHostElement();
626
627     // We are not always invoked consistently. For example, script execution can cause us to enter
628     // style recalc in the middle of tree building. We may also be invoked from somewhere within the tree.
629     // Reset the stack in this case, or if we see a new root element.
630     // Otherwise just push the new parent.
631     if (!parentsParent || m_checker.parentStackIsEmpty())
632         m_checker.setupParentStack(parent);
633     else
634         m_checker.pushParent(parent);
635
636     // Note: We mustn't skip ShadowRoot nodes for the scope stack.
637     pushScope(parent, parent->parentOrHostNode());
638 }
639
640 void StyleResolver::popParentElement(Element* parent)
641 {
642     // Note that we may get invoked for some random elements in some wacky cases during style resolve.
643     // Pause maintaining the stack in this case.
644     if (m_checker.parentStackIsConsistent(parent))
645         m_checker.popParent();
646     popScope(parent);
647 }
648
649 void StyleResolver::pushParentShadowRoot(const ShadowRoot* shadowRoot)
650 {
651     ASSERT(shadowRoot->host());
652     pushScope(shadowRoot, shadowRoot->host());
653 }
654
655 void StyleResolver::popParentShadowRoot(const ShadowRoot* shadowRoot)
656 {
657     ASSERT(shadowRoot->host());
658     popScope(shadowRoot);
659 }
660
661 // This is a simplified style setting function for keyframe styles
662 void StyleResolver::addKeyframeStyle(PassRefPtr<StyleRuleKeyframes> rule)
663 {
664     AtomicString s(rule->name());
665     m_keyframesRuleMap.set(s.impl(), rule);
666 }
667
668 StyleResolver::~StyleResolver()
669 {
670     m_fontSelector->clearDocument();
671 }
672
673 void StyleResolver::sweepMatchedPropertiesCache()
674 {
675     // Look for cache entries containing a style declaration with a single ref and remove them.
676     // This may happen when an element attribute mutation causes it to swap out its Attribute::decl()
677     // for another CSSMappedAttributeDeclaration, potentially leaving this cache with the last ref.
678     Vector<unsigned, 16> toRemove;
679     MatchedPropertiesCache::iterator it = m_matchedPropertiesCache.begin();
680     MatchedPropertiesCache::iterator end = m_matchedPropertiesCache.end();
681     for (; it != end; ++it) {
682         Vector<MatchedProperties>& matchedProperties = it->second.matchedProperties;
683         for (size_t i = 0; i < matchedProperties.size(); ++i) {
684             if (matchedProperties[i].properties->hasOneRef()) {
685                 toRemove.append(it->first);
686                 break;
687             }
688         }
689     }
690     for (size_t i = 0; i < toRemove.size(); ++i)
691         m_matchedPropertiesCache.remove(toRemove[i]);
692 }
693
694 StyleResolver::Features::Features()
695     : usesFirstLineRules(false)
696     , usesBeforeAfterRules(false)
697     , usesLinkRules(false)
698 {
699 }
700
701 StyleResolver::Features::~Features()
702 {
703 }
704     
705 void StyleResolver::Features::add(const StyleResolver::Features& other)
706 {
707     HashSet<AtomicStringImpl*>::iterator end = other.idsInRules.end();
708     for (HashSet<AtomicStringImpl*>::iterator it = other.idsInRules.begin(); it != end; ++it)
709         idsInRules.add(*it);
710     end = other.attrsInRules.end();
711     for (HashSet<AtomicStringImpl*>::iterator it = other.attrsInRules.begin(); it != end; ++it)
712         attrsInRules.add(*it);
713     siblingRules.append(other.siblingRules);
714     uncommonAttributeRules.append(other.uncommonAttributeRules);
715     usesFirstLineRules = usesFirstLineRules || other.usesFirstLineRules;
716     usesBeforeAfterRules = usesBeforeAfterRules || other.usesBeforeAfterRules;
717     usesLinkRules = usesLinkRules || other.usesLinkRules;
718 }
719
720 void StyleResolver::Features::clear()
721 {
722     idsInRules.clear();
723     attrsInRules.clear();
724     siblingRules.clear();
725     uncommonAttributeRules.clear();
726     usesFirstLineRules = false;
727     usesBeforeAfterRules = false;
728     usesLinkRules = false;
729 }
730
731 static StyleSheetContents* parseUASheet(const String& str)
732 {
733     StyleSheetContents* sheet = StyleSheetContents::create().leakRef(); // leak the sheet on purpose
734     sheet->parseString(str);
735     return sheet;
736 }
737
738 static StyleSheetContents* parseUASheet(const char* characters, unsigned size)
739 {
740     return parseUASheet(String(characters, size));
741 }
742
743 static void loadFullDefaultStyle()
744 {
745     if (simpleDefaultStyleSheet) {
746         ASSERT(defaultStyle);
747         ASSERT(defaultPrintStyle == defaultStyle);
748         delete defaultStyle;
749         simpleDefaultStyleSheet->deref();
750         defaultStyle = RuleSet::create().leakPtr();
751         defaultPrintStyle = RuleSet::create().leakPtr();
752         simpleDefaultStyleSheet = 0;
753     } else {
754         ASSERT(!defaultStyle);
755         defaultStyle = RuleSet::create().leakPtr();
756         defaultPrintStyle = RuleSet::create().leakPtr();
757         defaultQuirksStyle = RuleSet::create().leakPtr();
758     }
759
760     // Strict-mode rules.
761     String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraDefaultStyleSheet();
762     defaultStyleSheet = parseUASheet(defaultRules);
763     defaultStyle->addRulesFromSheet(defaultStyleSheet, screenEval());
764     defaultPrintStyle->addRulesFromSheet(defaultStyleSheet, printEval());
765
766     // Quirks-mode rules.
767     String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraQuirksStyleSheet();
768     quirksStyleSheet = parseUASheet(quirksRules);
769     defaultQuirksStyle->addRulesFromSheet(quirksStyleSheet, screenEval());
770 }
771
772 static void loadSimpleDefaultStyle()
773 {
774     ASSERT(!defaultStyle);
775     ASSERT(!simpleDefaultStyleSheet);
776
777     defaultStyle = RuleSet::create().leakPtr();
778     // There are no media-specific rules in the simple default style.
779     defaultPrintStyle = defaultStyle;
780     defaultQuirksStyle = RuleSet::create().leakPtr();
781
782     simpleDefaultStyleSheet = parseUASheet(simpleUserAgentStyleSheet, strlen(simpleUserAgentStyleSheet));
783     defaultStyle->addRulesFromSheet(simpleDefaultStyleSheet, screenEval());
784
785     // No need to initialize quirks sheet yet as there are no quirk rules for elements allowed in simple default style.
786 }
787
788 static void loadViewSourceStyle()
789 {
790     ASSERT(!defaultViewSourceStyle);
791     defaultViewSourceStyle = RuleSet::create().leakPtr();
792     defaultViewSourceStyle->addRulesFromSheet(parseUASheet(sourceUserAgentStyleSheet, sizeof(sourceUserAgentStyleSheet)), screenEval());
793 }
794
795 static void ensureDefaultStyleSheetsForElement(Element* element)
796 {
797     if (simpleDefaultStyleSheet && !elementCanUseSimpleDefaultStyle(element))
798         loadFullDefaultStyle();
799
800 #if ENABLE(SVG)
801     if (element->isSVGElement() && !svgStyleSheet) {
802         // SVG rules.
803         svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet));
804         defaultStyle->addRulesFromSheet(svgStyleSheet, screenEval());
805         defaultPrintStyle->addRulesFromSheet(svgStyleSheet, printEval());
806     }
807 #endif
808
809 #if ENABLE(MATHML)
810     if (element->isMathMLElement() && !mathMLStyleSheet) {
811         // MathML rules.
812         mathMLStyleSheet = parseUASheet(mathmlUserAgentStyleSheet, sizeof(mathmlUserAgentStyleSheet));
813         defaultStyle->addRulesFromSheet(mathMLStyleSheet, screenEval());
814         defaultPrintStyle->addRulesFromSheet(mathMLStyleSheet, printEval());
815     }
816 #endif
817
818 #if ENABLE(VIDEO)
819     if (!mediaControlsStyleSheet && (element->hasTagName(videoTag) || element->hasTagName(audioTag))) {
820         String mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::themeForPage(element->document()->page())->extraMediaControlsStyleSheet();
821         mediaControlsStyleSheet = parseUASheet(mediaRules);
822         defaultStyle->addRulesFromSheet(mediaControlsStyleSheet, screenEval());
823         defaultPrintStyle->addRulesFromSheet(mediaControlsStyleSheet, printEval());
824     }
825 #endif
826
827 #if ENABLE(FULLSCREEN_API)
828     if (!fullscreenStyleSheet && element->document()->webkitIsFullScreen()) {
829         String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraFullScreenStyleSheet();
830         fullscreenStyleSheet = parseUASheet(fullscreenRules);
831         defaultStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval());
832         defaultQuirksStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval());
833     }
834 #endif
835
836     ASSERT(defaultStyle->features().idsInRules.isEmpty());
837     ASSERT(mathMLStyleSheet || defaultStyle->features().siblingRules.isEmpty());
838 }
839
840 void StyleResolver::addMatchedProperties(MatchResult& matchResult, const StylePropertySet* properties, StyleRule* rule, unsigned linkMatchType, bool inRegionRule)
841 {
842     matchResult.matchedProperties.grow(matchResult.matchedProperties.size() + 1);
843     MatchedProperties& newProperties = matchResult.matchedProperties.last();
844     newProperties.properties = const_cast<StylePropertySet*>(properties);
845     newProperties.linkMatchType = linkMatchType;
846     newProperties.isInRegionRule = inRegionRule;
847     matchResult.matchedRules.append(rule);
848 }
849
850 inline void StyleResolver::addElementStyleProperties(MatchResult& result, StylePropertySet* propertySet, bool isCacheable)
851 {
852     if (!propertySet)
853         return;
854     result.ranges.lastAuthorRule = result.matchedProperties.size();
855     if (result.ranges.firstAuthorRule == -1)
856         result.ranges.firstAuthorRule = result.ranges.lastAuthorRule;
857     addMatchedProperties(result, propertySet);
858     if (!isCacheable)
859         result.isCacheable = false;
860 }
861
862 void StyleResolver::collectMatchingRules(RuleSet* rules, int& firstRuleIndex, int& lastRuleIndex, const MatchOptions& options)
863 {
864     ASSERT(rules);
865     ASSERT(m_element);
866
867     // We need to collect the rules for id, class, tag, and everything else into a buffer and
868     // then sort the buffer.
869     if (m_element->hasID())
870         collectMatchingRulesForList(rules->idRules(m_element->idForStyleResolution().impl()), firstRuleIndex, lastRuleIndex, options);
871     if (m_element->hasClass()) {
872         ASSERT(m_styledElement);
873         const SpaceSplitString& classNames = m_styledElement->classNames();
874         size_t size = classNames.size();
875         for (size_t i = 0; i < size; ++i)
876             collectMatchingRulesForList(rules->classRules(classNames[i].impl()), firstRuleIndex, lastRuleIndex, options);
877     }
878     const AtomicString& pseudoId = m_element->shadowPseudoId();
879     if (!pseudoId.isEmpty()) {
880         ASSERT(m_styledElement);
881         collectMatchingRulesForList(rules->shadowPseudoElementRules(pseudoId.impl()), firstRuleIndex, lastRuleIndex, options);
882     }
883     if (m_element->isLink())
884         collectMatchingRulesForList(rules->linkPseudoClassRules(), firstRuleIndex, lastRuleIndex, options);
885     if (m_checker.matchesFocusPseudoClass(m_element))
886         collectMatchingRulesForList(rules->focusPseudoClassRules(), firstRuleIndex, lastRuleIndex, options);
887     collectMatchingRulesForList(rules->tagRules(m_element->localName().impl()), firstRuleIndex, lastRuleIndex, options);
888     collectMatchingRulesForList(rules->universalRules(), firstRuleIndex, lastRuleIndex, options);
889 }
890
891 void StyleResolver::collectMatchingRulesForRegion(RuleSet* rules, int& firstRuleIndex, int& lastRuleIndex, const MatchOptions& options)
892 {
893     if (!m_regionForStyling)
894         return;
895
896     unsigned size = rules->m_regionSelectorsAndRuleSets.size();
897     for (unsigned i = 0; i < size; ++i) {
898         CSSSelector* regionSelector = rules->m_regionSelectorsAndRuleSets.at(i).selector;
899         if (checkRegionSelector(regionSelector, static_cast<Element*>(m_regionForStyling->node()))) {
900             RuleSet* regionRules = rules->m_regionSelectorsAndRuleSets.at(i).ruleSet.get();
901             ASSERT(regionRules);
902             collectMatchingRules(regionRules, firstRuleIndex, lastRuleIndex, options);
903         }
904     }
905 }
906
907 void StyleResolver::sortAndTransferMatchedRules(MatchResult& result)
908 {
909     if (m_matchedRules.isEmpty())
910         return;
911
912     sortMatchedRules();
913
914     if (m_checker.mode() == SelectorChecker::CollectingRules) {
915         if (!m_ruleList)
916             m_ruleList = StaticCSSRuleList::create();
917         for (unsigned i = 0; i < m_matchedRules.size(); ++i)
918             m_ruleList->rules().append(m_matchedRules[i]->rule()->createCSSOMWrapper());
919         return;
920     }
921
922     // Now transfer the set of matched rules over to our list of declarations.
923     // FIXME: This sucks, the inspector should get the style from the visited style itself.
924     bool swapVisitedUnvisited = InspectorInstrumentation::forcePseudoState(m_element, CSSSelector::PseudoVisited);
925     for (unsigned i = 0; i < m_matchedRules.size(); i++) {
926         if (m_style && m_matchedRules[i]->containsUncommonAttributeSelector())
927             m_style->setAffectedByUncommonAttributeSelectors();
928         unsigned linkMatchType = m_matchedRules[i]->linkMatchType();
929         if (swapVisitedUnvisited && linkMatchType && linkMatchType != SelectorChecker::MatchAll)
930             linkMatchType = (linkMatchType == SelectorChecker::MatchVisited) ? SelectorChecker::MatchLink : SelectorChecker::MatchVisited;
931         addMatchedProperties(result, m_matchedRules[i]->rule()->properties(), m_matchedRules[i]->rule(), linkMatchType, m_matchedRules[i]->isInRegionRule());
932     }
933 }
934
935 void StyleResolver::matchScopedAuthorRules(MatchResult& result, bool includeEmptyRules)
936 {
937 #if ENABLE(STYLE_SCOPED)
938     if (m_scopedAuthorStyles.isEmpty())
939         return;
940
941     MatchOptions options(includeEmptyRules);
942
943     // Match scoped author rules by traversing the scoped element stack (rebuild it if it got inconsistent).
944     if (!scopeStackIsConsistent(m_element))
945         setupScopeStack(m_element);
946
947     unsigned int firstShadowScopeIndex = 0;
948     if (m_element->treeScope()->applyAuthorStyles()) {
949         unsigned i;
950         for (i = 0; i < m_scopeStack.size() && !m_scopeStack[i].m_scope->isInShadowTree(); ++i) {
951             const ScopeStackFrame& frame = m_scopeStack[i];
952             options.scope = frame.m_scope;
953             collectMatchingRules(frame.m_ruleSet, result.ranges.firstAuthorRule, result.ranges.lastAuthorRule, options);
954             collectMatchingRulesForRegion(frame.m_ruleSet, result.ranges.firstAuthorRule, result.ranges.lastAuthorRule, options);
955         }
956         firstShadowScopeIndex = i;
957     }
958
959     if (!m_element->isInShadowTree() || m_scopeStack.isEmpty())
960         return;
961
962     unsigned scopedIndex = m_scopeStack.size();
963     int authorStyleBoundsIndex = m_scopeStackParentBoundsIndex;
964     for ( ; scopedIndex > firstShadowScopeIndex; --scopedIndex) {
965         if (authorStyleBoundsIndex != m_scopeStack[scopedIndex - 1].m_authorStyleBoundsIndex)
966             break;
967     }
968
969     // Ruleset for ancestor nodes should be applied first.
970     for (unsigned i = scopedIndex; i < m_scopeStack.size(); ++i) {
971         const ScopeStackFrame& frame = m_scopeStack[i];
972         options.scope = frame.m_scope;
973         collectMatchingRules(frame.m_ruleSet, result.ranges.firstAuthorRule, result.ranges.lastAuthorRule, options);
974         collectMatchingRulesForRegion(frame.m_ruleSet, result.ranges.firstAuthorRule, result.ranges.lastAuthorRule, options);
975     }
976 #else
977     UNUSED_PARAM(result);
978     UNUSED_PARAM(includeEmptyRules);
979 #endif
980 }
981
982 void StyleResolver::matchAuthorRules(MatchResult& result, bool includeEmptyRules)
983 {
984     m_matchedRules.clear();
985     result.ranges.lastAuthorRule = result.matchedProperties.size() - 1;
986
987     if (!m_element)
988         return;
989
990     // Match global author rules.
991     MatchOptions options(includeEmptyRules);
992     collectMatchingRules(m_authorStyle.get(), result.ranges.firstAuthorRule, result.ranges.lastAuthorRule, options);
993     collectMatchingRulesForRegion(m_authorStyle.get(), result.ranges.firstAuthorRule, result.ranges.lastAuthorRule, options);
994
995     matchScopedAuthorRules(result, includeEmptyRules);
996
997     sortAndTransferMatchedRules(result);
998 }
999
1000 void StyleResolver::matchUserRules(MatchResult& result, bool includeEmptyRules)
1001 {
1002     if (!m_userStyle)
1003         return;
1004     
1005     m_matchedRules.clear();
1006
1007     result.ranges.lastUserRule = result.matchedProperties.size() - 1;
1008     collectMatchingRules(m_userStyle.get(), result.ranges.firstUserRule, result.ranges.lastUserRule, includeEmptyRules);
1009     collectMatchingRulesForRegion(m_userStyle.get(), result.ranges.firstUserRule, result.ranges.lastUserRule, includeEmptyRules);
1010
1011     sortAndTransferMatchedRules(result);
1012 }
1013
1014 void StyleResolver::matchUARules(MatchResult& result, RuleSet* rules)
1015 {
1016     m_matchedRules.clear();
1017     
1018     result.ranges.lastUARule = result.matchedProperties.size() - 1;
1019     collectMatchingRules(rules, result.ranges.firstUARule, result.ranges.lastUARule, false);
1020
1021     sortAndTransferMatchedRules(result);
1022 }
1023
1024 class MatchingUARulesScope {
1025 public:
1026     MatchingUARulesScope();
1027     ~MatchingUARulesScope();
1028
1029     static bool isMatchingUARules();
1030
1031 private:
1032     static bool m_matchingUARules;
1033 };
1034
1035 MatchingUARulesScope::MatchingUARulesScope()
1036 {
1037     ASSERT(!m_matchingUARules);
1038     m_matchingUARules = true;
1039 }
1040
1041 MatchingUARulesScope::~MatchingUARulesScope()
1042 {
1043     m_matchingUARules = false;
1044 }
1045
1046 inline bool MatchingUARulesScope::isMatchingUARules()
1047 {
1048     return m_matchingUARules;
1049 }
1050
1051 bool MatchingUARulesScope::m_matchingUARules = false;
1052
1053 void StyleResolver::collectMatchingRulesForList(const Vector<RuleData>* rules, int& firstRuleIndex, int& lastRuleIndex, const MatchOptions& options)
1054 {
1055     if (!rules)
1056         return;
1057     // In some cases we may end up looking up style for random elements in the middle of a recursive tree resolve.
1058     // Ancestor identifier filter won't be up-to-date in that case and we can't use the fast path.
1059     bool canUseFastReject = m_checker.parentStackIsConsistent(m_parentNode);
1060
1061     unsigned size = rules->size();
1062     for (unsigned i = 0; i < size; ++i) {
1063         const RuleData& ruleData = rules->at(i);
1064         if (canUseFastReject && m_checker.fastRejectSelector<RuleData::maximumIdentifierCount>(ruleData.descendantSelectorIdentifierHashes()))
1065             continue;
1066
1067         StyleRule* rule = ruleData.rule();
1068         InspectorInstrumentationCookie cookie = InspectorInstrumentation::willMatchRule(document(), rule);
1069 #if ENABLE(STYLE_SCOPED)
1070         if (checkSelector(ruleData, options.scope)) {
1071 #else
1072         if (checkSelector(ruleData)) {
1073 #endif
1074             // Check whether the rule is applicable in the current tree scope. Criteria for this:
1075             // a) it's a UA rule
1076             // b) the tree scope allows author rules
1077             // c) the rules comes from a scoped style sheet within the same tree scope
1078             // d) the rule contains shadow-ID pseudo elements
1079             TreeScope* treeScope = m_element->treeScope();
1080             if (!MatchingUARulesScope::isMatchingUARules()
1081                 && !treeScope->applyAuthorStyles()
1082 #if ENABLE(STYLE_SCOPED)
1083                 && (!options.scope || options.scope->treeScope() != treeScope)
1084 #endif
1085                 && !m_checker.hasUnknownPseudoElements()) {
1086
1087                 InspectorInstrumentation::didMatchRule(cookie, false);
1088                 continue;
1089             }
1090             // If the rule has no properties to apply, then ignore it in the non-debug mode.
1091             const StylePropertySet* properties = rule->properties();
1092             if (!properties || (properties->isEmpty() && !options.includeEmptyRules)) {
1093                 InspectorInstrumentation::didMatchRule(cookie, false);
1094                 continue;
1095             }
1096             // FIXME: Exposing the non-standard getMatchedCSSRules API to web is the only reason this is needed.
1097             if (m_sameOriginOnly && !ruleData.hasDocumentSecurityOrigin()) {
1098                 InspectorInstrumentation::didMatchRule(cookie, false);
1099                 continue;
1100             }
1101             // If we're matching normal rules, set a pseudo bit if
1102             // we really just matched a pseudo-element.
1103             if (m_dynamicPseudo != NOPSEUDO && m_checker.pseudoStyle() == NOPSEUDO) {
1104                 if (m_checker.mode() == SelectorChecker::CollectingRules) {
1105                     InspectorInstrumentation::didMatchRule(cookie, false);
1106                     continue;
1107                 }
1108                 if (m_dynamicPseudo < FIRST_INTERNAL_PSEUDOID)
1109                     m_style->setHasPseudoStyle(m_dynamicPseudo);
1110             } else {
1111                 // Update our first/last rule indices in the matched rules array.
1112                 ++lastRuleIndex;
1113                 if (firstRuleIndex == -1)
1114                     firstRuleIndex = lastRuleIndex;
1115
1116                 // Add this rule to our list of matched rules.
1117                 addMatchedRule(&ruleData);
1118                 InspectorInstrumentation::didMatchRule(cookie, true);
1119                 continue;
1120             }
1121         }
1122         InspectorInstrumentation::didMatchRule(cookie, false);
1123     }
1124 }
1125
1126 static inline bool compareRules(const RuleData* r1, const RuleData* r2)
1127 {
1128     unsigned specificity1 = r1->specificity();
1129     unsigned specificity2 = r2->specificity();
1130     return (specificity1 == specificity2) ? r1->position() < r2->position() : specificity1 < specificity2;
1131 }
1132
1133 void StyleResolver::sortMatchedRules()
1134 {
1135     std::sort(m_matchedRules.begin(), m_matchedRules.end(), compareRules);
1136 }
1137
1138 void StyleResolver::matchAllRules(MatchResult& result, bool includeSMILProperties)
1139 {
1140     matchUARules(result);
1141
1142     // Now we check user sheet rules.
1143     if (m_matchAuthorAndUserStyles)
1144         matchUserRules(result, false);
1145         
1146     // Now check author rules, beginning first with presentational attributes mapped from HTML.
1147     if (m_styledElement) {
1148         addElementStyleProperties(result, m_styledElement->attributeStyle());
1149
1150         // Now we check additional mapped declarations.
1151         // Tables and table cells share an additional mapped rule that must be applied
1152         // after all attributes, since their mapped style depends on the values of multiple attributes.
1153         addElementStyleProperties(result, m_styledElement->additionalAttributeStyle());
1154
1155         if (m_styledElement->isHTMLElement()) {
1156             bool isAuto;
1157             TextDirection textDirection = toHTMLElement(m_styledElement)->directionalityIfhasDirAutoAttribute(isAuto);
1158             if (isAuto)
1159                 addMatchedProperties(result, textDirection == LTR ? leftToRightDeclaration() : rightToLeftDeclaration());
1160         }
1161     }
1162     
1163     // Check the rules in author sheets next.
1164     if (m_matchAuthorAndUserStyles)
1165         matchAuthorRules(result, false);
1166
1167     // Now check our inline style attribute.
1168     if (m_matchAuthorAndUserStyles && m_styledElement && m_styledElement->inlineStyle()) {
1169         // Inline style is immutable as long as there is no CSSOM wrapper.
1170         // FIXME: Media control shadow trees seem to have problems with caching.
1171         bool isInlineStyleCacheable = !m_styledElement->inlineStyle()->isMutable() && !m_styledElement->isInShadowTree();
1172         // FIXME: Constify.
1173         addElementStyleProperties(result, const_cast<StylePropertySet*>(m_styledElement->inlineStyle()), isInlineStyleCacheable);
1174     }
1175
1176 #if ENABLE(SVG)
1177     // Now check SMIL animation override style.
1178     if (includeSMILProperties && m_matchAuthorAndUserStyles && m_styledElement && m_styledElement->isSVGElement())
1179         addElementStyleProperties(result, static_cast<SVGElement*>(m_styledElement)->animatedSMILStyleProperties(), false /* isCacheable */);
1180 #else
1181     UNUSED_PARAM(includeSMILProperties);
1182 #endif
1183 }
1184
1185 inline void StyleResolver::initElement(Element* e)
1186 {
1187     if (m_element != e) {
1188         m_element = e;
1189         m_styledElement = m_element && m_element->isStyledElement() ? static_cast<StyledElement*>(m_element) : 0;
1190         m_elementLinkState = m_checker.determineLinkState(m_element);
1191         if (e && e == e->document()->documentElement()) {
1192             e->document()->setDirectionSetOnDocumentElement(false);
1193             e->document()->setWritingModeSetOnDocumentElement(false);
1194         }
1195     }
1196 }
1197
1198 inline void StyleResolver::initForStyleResolve(Element* e, RenderStyle* parentStyle, PseudoId pseudoID)
1199 {
1200     m_checker.setPseudoStyle(pseudoID);
1201
1202     if (e) {
1203         NodeRenderingContext context(e);
1204         m_parentNode = context.parentNodeForRenderingAndStyle();
1205         m_parentStyle = context.resetStyleInheritance()? 0 :
1206             parentStyle ? parentStyle :
1207             m_parentNode ? m_parentNode->renderStyle() : 0;
1208     } else {
1209         m_parentNode = 0;
1210         m_parentStyle = parentStyle;
1211     }
1212
1213     Node* docElement = e ? e->document()->documentElement() : 0;
1214     RenderStyle* docStyle = m_checker.document()->renderStyle();
1215     m_rootElementStyle = docElement && e != docElement ? docElement->renderStyle() : docStyle;
1216
1217     m_style = 0;
1218
1219     m_pendingImageProperties.clear();
1220
1221     m_ruleList = 0;
1222
1223     m_fontDirty = false;
1224 }
1225
1226 static const unsigned cStyleSearchThreshold = 10;
1227 static const unsigned cStyleSearchLevelThreshold = 10;
1228
1229 Node* StyleResolver::locateCousinList(Element* parent, unsigned& visitedNodeCount) const
1230 {
1231     if (visitedNodeCount >= cStyleSearchThreshold * cStyleSearchLevelThreshold)
1232         return 0;
1233     if (!parent || !parent->isStyledElement())
1234         return 0;
1235 #if ENABLE(STYLE_SCOPED)
1236     if (parent->hasScopedHTMLStyleChild())
1237         return 0;
1238 #endif
1239     StyledElement* p = static_cast<StyledElement*>(parent);
1240     if (p->inlineStyle())
1241         return 0;
1242 #if ENABLE(SVG)
1243     if (p->isSVGElement() && static_cast<SVGElement*>(p)->animatedSMILStyleProperties())
1244         return 0;
1245 #endif
1246     if (p->hasID() && m_features.idsInRules.contains(p->idForStyleResolution().impl()))
1247         return 0;
1248
1249     RenderStyle* parentStyle = p->renderStyle();
1250     unsigned subcount = 0;
1251     Node* thisCousin = p;
1252     Node* currentNode = p->previousSibling();
1253
1254     // Reserve the tries for this level. This effectively makes sure that the algorithm
1255     // will never go deeper than cStyleSearchLevelThreshold levels into recursion.
1256     visitedNodeCount += cStyleSearchThreshold;
1257     while (thisCousin) {
1258         while (currentNode) {
1259             ++subcount;
1260             if (currentNode->renderStyle() == parentStyle && currentNode->lastChild()) {
1261                 // Adjust for unused reserved tries.
1262                 visitedNodeCount -= cStyleSearchThreshold - subcount;
1263                 return currentNode->lastChild();
1264             }
1265             if (subcount >= cStyleSearchThreshold)
1266                 return 0;
1267             currentNode = currentNode->previousSibling();
1268         }
1269         currentNode = locateCousinList(thisCousin->parentElement(), visitedNodeCount);
1270         thisCousin = currentNode;
1271     }
1272
1273     return 0;
1274 }
1275
1276 bool StyleResolver::matchesRuleSet(RuleSet* ruleSet)
1277 {
1278     if (!ruleSet)
1279         return false;
1280     m_matchedRules.clear();
1281
1282     int firstRuleIndex = -1, lastRuleIndex = -1;
1283     collectMatchingRules(ruleSet, firstRuleIndex, lastRuleIndex, false);
1284
1285     if (m_matchedRules.isEmpty())
1286         return false;
1287     m_matchedRules.clear();
1288     return true;
1289 }
1290
1291 bool StyleResolver::canShareStyleWithControl(StyledElement* element) const
1292 {
1293     HTMLInputElement* thisInputElement = element->toInputElement();
1294     HTMLInputElement* otherInputElement = m_element->toInputElement();
1295
1296     if (!thisInputElement || !otherInputElement)
1297         return false;
1298
1299     if (thisInputElement->isAutofilled() != otherInputElement->isAutofilled())
1300         return false;
1301     if (thisInputElement->shouldAppearChecked() != otherInputElement->shouldAppearChecked())
1302         return false;
1303     if (thisInputElement->isIndeterminate() != otherInputElement->isIndeterminate())
1304         return false;
1305     if (thisInputElement->required() != otherInputElement->required())
1306         return false;
1307
1308     if (element->isEnabledFormControl() != m_element->isEnabledFormControl())
1309         return false;
1310
1311     if (element->isDefaultButtonForForm() != m_element->isDefaultButtonForForm())
1312         return false;
1313
1314     if (m_element->document()->containsValidityStyleRules()) {
1315         bool willValidate = element->willValidate();
1316
1317         if (willValidate != m_element->willValidate())
1318             return false;
1319
1320         if (willValidate && (element->isValidFormControlElement() != m_element->isValidFormControlElement()))
1321             return false;
1322
1323         if (element->isInRange() != m_element->isInRange())
1324             return false;
1325
1326         if (element->isOutOfRange() != m_element->isOutOfRange())
1327             return false;
1328     }
1329
1330     return true;
1331 }
1332
1333 // This function makes some assumptions that only make sense for attribute styles (we only compare CSSProperty::id() and CSSProperty::value().)
1334 static inline bool attributeStylesEqual(StylePropertySet* a, StylePropertySet* b)
1335 {
1336     if (a == b)
1337         return true;
1338     if (a->propertyCount() != b->propertyCount())
1339         return false;
1340     unsigned propertyCount = a->propertyCount();
1341     for (unsigned i = 0; i < propertyCount; ++i) {
1342         const CSSProperty& aProperty = a->propertyAt(i);
1343         unsigned j;
1344         for (j = 0; j < propertyCount; ++j) {
1345             const CSSProperty& bProperty = b->propertyAt(j);
1346             if (aProperty.id() != bProperty.id())
1347                 continue;
1348             // We could get a few more hits by comparing cssText() here, but that gets expensive quickly.
1349             if (aProperty.value() != bProperty.value())
1350                 return false;
1351             break;
1352         }
1353         if (j == propertyCount)
1354             return false;
1355     }
1356     return true;
1357 }
1358
1359 inline bool elementHasDirectionAuto(Element* element)
1360 {
1361     return element->isHTMLElement() && toHTMLElement(element)->hasDirectionAuto();
1362 }
1363
1364 bool StyleResolver::canShareStyleWithElement(StyledElement* element) const
1365 {
1366     RenderStyle* style = element->renderStyle();
1367
1368     if (!style)
1369         return false;
1370     if (style->unique())
1371         return false;
1372     if (element->tagQName() != m_element->tagQName())
1373         return false;
1374     if (element->hasClass() != m_element->hasClass())
1375         return false;
1376     if (element->inlineStyle())
1377         return false;
1378 #if ENABLE(SVG)
1379     if (element->isSVGElement() && static_cast<SVGElement*>(element)->animatedSMILStyleProperties())
1380         return false;
1381 #endif
1382     if (!!element->attributeStyle() != !!m_styledElement->attributeStyle())
1383         return false;
1384     StylePropertySet* additionalAttributeStyleA = element->additionalAttributeStyle();
1385     StylePropertySet* additionalAttributeStyleB = m_styledElement->additionalAttributeStyle();
1386     if (!additionalAttributeStyleA != !additionalAttributeStyleB)
1387         return false;
1388     if (element->isLink() != m_element->isLink())
1389         return false;
1390     if (style->affectedByUncommonAttributeSelectors())
1391         return false;
1392     if (element->hovered() != m_element->hovered())
1393         return false;
1394     if (element->active() != m_element->active())
1395         return false;
1396     if (element->focused() != m_element->focused())
1397         return false;
1398     if (element->shadowPseudoId() != m_element->shadowPseudoId())
1399         return false;
1400     if (element == element->document()->cssTarget())
1401         return false;
1402     if (m_element == m_element->document()->cssTarget())
1403         return false;
1404     if (element->getAttribute(typeAttr) != m_element->getAttribute(typeAttr))
1405         return false;
1406     if (element->fastGetAttribute(XMLNames::langAttr) != m_element->fastGetAttribute(XMLNames::langAttr))
1407         return false;
1408     if (element->fastGetAttribute(langAttr) != m_element->fastGetAttribute(langAttr))
1409         return false;
1410     if (element->fastGetAttribute(readonlyAttr) != m_element->fastGetAttribute(readonlyAttr))
1411         return false;
1412     if (element->fastGetAttribute(cellpaddingAttr) != m_element->fastGetAttribute(cellpaddingAttr))
1413         return false;
1414
1415     if (element->hasID() && m_features.idsInRules.contains(element->idForStyleResolution().impl()))
1416         return false;
1417
1418 #if ENABLE(STYLE_SCOPED)
1419     if (element->hasScopedHTMLStyleChild())
1420         return false;
1421 #endif
1422
1423 #if ENABLE(PROGRESS_TAG)
1424     if (element->hasTagName(progressTag)) {
1425         if (!m_element->hasTagName(progressTag))
1426             return false;
1427
1428         HTMLProgressElement* thisProgressElement = static_cast<HTMLProgressElement*>(element);
1429         HTMLProgressElement* otherProgressElement = static_cast<HTMLProgressElement*>(m_element);
1430         if (thisProgressElement->isDeterminate() != otherProgressElement->isDeterminate())
1431             return false;
1432     }
1433 #endif
1434
1435     // FIXME: We should share style for option and optgroup whenever possible.
1436     // Before doing so, we need to resolve issues in HTMLSelectElement::recalcListItems
1437     // and RenderMenuList::setText. See also https://bugs.webkit.org/show_bug.cgi?id=88405
1438     if (element->hasTagName(optionTag) || element->hasTagName(optgroupTag))
1439         return false;
1440
1441     bool isControl = element->isFormControlElement();
1442
1443     if (isControl != m_element->isFormControlElement())
1444         return false;
1445
1446     if (isControl && !canShareStyleWithControl(element))
1447         return false;
1448
1449     if (style->transitions() || style->animations())
1450         return false;
1451
1452 #if USE(ACCELERATED_COMPOSITING)
1453     // Turn off style sharing for elements that can gain layers for reasons outside of the style system.
1454     // See comments in RenderObject::setStyle().
1455     if (element->hasTagName(iframeTag) || element->hasTagName(frameTag) || element->hasTagName(embedTag) || element->hasTagName(objectTag) || element->hasTagName(appletTag)
1456 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
1457         // With proxying, the media elements are backed by a RenderEmbeddedObject.
1458         || element->hasTagName(videoTag) || element->hasTagName(audioTag)
1459 #endif
1460         )
1461         return false;
1462 #endif
1463
1464     if (elementHasDirectionAuto(element) || elementHasDirectionAuto(m_element))
1465         return false;
1466
1467     if (element->hasClass() && m_element->getAttribute(classAttr) != element->getAttribute(classAttr))
1468         return false;
1469
1470     if (element->attributeStyle() && !attributeStylesEqual(element->attributeStyle(), m_styledElement->attributeStyle()))
1471         return false;
1472
1473     if (additionalAttributeStyleA && !attributeStylesEqual(additionalAttributeStyleA, additionalAttributeStyleB))
1474         return false;
1475
1476     if (element->isLink() && m_elementLinkState != style->insideLink())
1477         return false;
1478
1479     return true;
1480 }
1481
1482 inline StyledElement* StyleResolver::findSiblingForStyleSharing(Node* node, unsigned& count) const
1483 {
1484     for (; node; node = node->previousSibling()) {
1485         if (!node->isStyledElement())
1486             continue;
1487         if (canShareStyleWithElement(static_cast<StyledElement*>(node)))
1488             break;
1489         if (count++ == cStyleSearchThreshold)
1490             return 0;
1491     }
1492     return static_cast<StyledElement*>(node);
1493 }
1494
1495 static inline bool parentStylePreventsSharing(const RenderStyle* parentStyle)
1496 {
1497     return parentStyle->childrenAffectedByPositionalRules()
1498         || parentStyle->childrenAffectedByFirstChildRules()
1499         || parentStyle->childrenAffectedByLastChildRules() 
1500         || parentStyle->childrenAffectedByDirectAdjacentRules();
1501 }
1502
1503 RenderStyle* StyleResolver::locateSharedStyle()
1504 {
1505     if (!m_styledElement || !m_parentStyle)
1506         return 0;
1507     // If the element has inline style it is probably unique.
1508     if (m_styledElement->inlineStyle())
1509         return 0;
1510 #if ENABLE(SVG)
1511     if (m_styledElement->isSVGElement() && static_cast<SVGElement*>(m_styledElement)->animatedSMILStyleProperties())
1512         return 0;
1513 #endif
1514     // Ids stop style sharing if they show up in the stylesheets.
1515     if (m_styledElement->hasID() && m_features.idsInRules.contains(m_styledElement->idForStyleResolution().impl()))
1516         return 0;
1517     if (parentStylePreventsSharing(m_parentStyle))
1518         return 0;
1519 #if ENABLE(STYLE_SCOPED)
1520     if (m_styledElement->hasScopedHTMLStyleChild())
1521         return 0;
1522 #endif
1523
1524     // Check previous siblings and their cousins.
1525     unsigned count = 0;
1526     unsigned visitedNodeCount = 0;
1527     StyledElement* shareElement = 0;
1528     Node* cousinList = m_styledElement->previousSibling();
1529     while (cousinList) {
1530         shareElement = findSiblingForStyleSharing(cousinList, count);
1531         if (shareElement)
1532             break;
1533         cousinList = locateCousinList(cousinList->parentElement(), visitedNodeCount);
1534     }
1535
1536     // If we have exhausted all our budget or our cousins.
1537     if (!shareElement)
1538         return 0;
1539
1540     // Can't share if sibling rules apply. This is checked at the end as it should rarely fail.
1541     if (matchesRuleSet(m_siblingRuleSet.get()))
1542         return 0;
1543     // Can't share if attribute rules apply.
1544     if (matchesRuleSet(m_uncommonAttributeRuleSet.get()))
1545         return 0;
1546     // Tracking child index requires unique style for each node. This may get set by the sibling rule match above.
1547     if (parentStylePreventsSharing(m_parentStyle))
1548         return 0;
1549     return shareElement->renderStyle();
1550 }
1551
1552 void StyleResolver::matchUARules(MatchResult& result)
1553 {
1554     MatchingUARulesScope scope;
1555
1556     // First we match rules from the user agent sheet.
1557     if (simpleDefaultStyleSheet)
1558         result.isCacheable = false;
1559     RuleSet* userAgentStyleSheet = m_medium->mediaTypeMatchSpecific("print")
1560         ? defaultPrintStyle : defaultStyle;
1561     matchUARules(result, userAgentStyleSheet);
1562
1563     // In quirks mode, we match rules from the quirks user agent sheet.
1564     if (!m_checker.strictParsing())
1565         matchUARules(result, defaultQuirksStyle);
1566
1567     // If document uses view source styles (in view source mode or in xml viewer mode), then we match rules from the view source style sheet.
1568     if (m_checker.document()->isViewSource()) {
1569         if (!defaultViewSourceStyle)
1570             loadViewSourceStyle();
1571         matchUARules(result, defaultViewSourceStyle);
1572     }
1573 }
1574
1575 PassRefPtr<RenderStyle> StyleResolver::styleForDocument(Document* document, CSSFontSelector* fontSelector)
1576 {
1577     Frame* frame = document->frame();
1578
1579     // HTML5 states that seamless iframes should replace default CSS values
1580     // with values inherited from the containing iframe element. However,
1581     // some values (such as the case of designMode = "on") still need to
1582     // be set by this "document style".
1583     RefPtr<RenderStyle> documentStyle = RenderStyle::create();
1584     bool seamlessWithParent = document->shouldDisplaySeamlesslyWithParent();
1585     if (seamlessWithParent) {
1586         RenderStyle* iframeStyle = document->seamlessParentIFrame()->renderStyle();
1587         if (iframeStyle)
1588             documentStyle->inheritFrom(iframeStyle);
1589     }
1590
1591     // FIXME: It's not clear which values below we want to override in the seamless case!
1592     documentStyle->setDisplay(BLOCK);
1593     if (!seamlessWithParent) {
1594         documentStyle->setRTLOrdering(document->visuallyOrdered() ? VisualOrder : LogicalOrder);
1595         documentStyle->setZoom(frame && !document->printing() ? frame->pageZoomFactor() : 1);
1596         documentStyle->setPageScaleTransform(frame ? frame->frameScaleFactor() : 1);
1597         documentStyle->setLocale(document->contentLanguage());
1598     }
1599     // FIXME: This overrides any -webkit-user-modify inherited from the parent iframe.
1600     documentStyle->setUserModify(document->inDesignMode() ? READ_WRITE : READ_ONLY);
1601
1602     Element* docElement = document->documentElement();
1603     RenderObject* docElementRenderer = docElement ? docElement->renderer() : 0;
1604     if (docElementRenderer) {
1605         // Use the direction and writing-mode of the body to set the
1606         // viewport's direction and writing-mode unless the property is set on the document element.
1607         // If there is no body, then use the document element.
1608         RenderObject* bodyRenderer = document->body() ? document->body()->renderer() : 0;
1609         if (bodyRenderer && !document->writingModeSetOnDocumentElement())
1610             documentStyle->setWritingMode(bodyRenderer->style()->writingMode());
1611         else
1612             documentStyle->setWritingMode(docElementRenderer->style()->writingMode());
1613         if (bodyRenderer && !document->directionSetOnDocumentElement())
1614             documentStyle->setDirection(bodyRenderer->style()->direction());
1615         else
1616             documentStyle->setDirection(docElementRenderer->style()->direction());
1617     }
1618
1619     if (frame) {
1620         if (Page* page = frame->page()) {
1621             const Page::Pagination& pagination = page->pagination();
1622             if (pagination.mode != Page::Pagination::Unpaginated) {
1623                 switch (pagination.mode) {
1624                 case Page::Pagination::LeftToRightPaginated:
1625                     documentStyle->setColumnAxis(HorizontalColumnAxis);
1626                     if (documentStyle->isHorizontalWritingMode())
1627                         documentStyle->setColumnProgression(documentStyle->isLeftToRightDirection() ? NormalColumnProgression : ReverseColumnProgression);
1628                     else
1629                         documentStyle->setColumnProgression(documentStyle->isFlippedBlocksWritingMode() ? ReverseColumnProgression : NormalColumnProgression);
1630                     break;
1631                 case Page::Pagination::RightToLeftPaginated:
1632                     documentStyle->setColumnAxis(HorizontalColumnAxis);
1633                     if (documentStyle->isHorizontalWritingMode())
1634                         documentStyle->setColumnProgression(documentStyle->isLeftToRightDirection() ? ReverseColumnProgression : NormalColumnProgression);
1635                     else
1636                         documentStyle->setColumnProgression(documentStyle->isFlippedBlocksWritingMode() ? NormalColumnProgression : ReverseColumnProgression);
1637                     break;
1638                 case Page::Pagination::TopToBottomPaginated:
1639                     documentStyle->setColumnAxis(VerticalColumnAxis);
1640                     if (documentStyle->isHorizontalWritingMode())
1641                         documentStyle->setColumnProgression(documentStyle->isFlippedBlocksWritingMode() ? ReverseColumnProgression : NormalColumnProgression);
1642                     else
1643                         documentStyle->setColumnProgression(documentStyle->isLeftToRightDirection() ? NormalColumnProgression : ReverseColumnProgression);
1644                     break;
1645                 case Page::Pagination::BottomToTopPaginated:
1646                     documentStyle->setColumnAxis(VerticalColumnAxis);
1647                     if (documentStyle->isHorizontalWritingMode())
1648                         documentStyle->setColumnProgression(documentStyle->isFlippedBlocksWritingMode() ? NormalColumnProgression : ReverseColumnProgression);
1649                     else
1650                         documentStyle->setColumnProgression(documentStyle->isLeftToRightDirection() ? ReverseColumnProgression : NormalColumnProgression);
1651                     break;
1652                 case Page::Pagination::Unpaginated:
1653                     ASSERT_NOT_REACHED();
1654                     break;
1655                 }
1656
1657                 documentStyle->setColumnGap(pagination.gap);
1658             }
1659         }
1660     }
1661
1662     // Seamless iframes want to inherit their font from their parent iframe, so early return before setting the font.
1663     if (seamlessWithParent)
1664         return documentStyle.release();
1665
1666     FontDescription fontDescription;
1667     fontDescription.setUsePrinterFont(document->printing());
1668     fontDescription.setScript(localeToScriptCodeForFontSelection(documentStyle->locale()));
1669     if (Settings* settings = document->settings()) {
1670         fontDescription.setRenderingMode(settings->fontRenderingMode());
1671         const AtomicString& standardFont = settings->standardFontFamily(fontDescription.script());
1672         if (!standardFont.isEmpty()) {
1673             fontDescription.setGenericFamily(FontDescription::StandardFamily);
1674             fontDescription.firstFamily().setFamily(standardFont);
1675             fontDescription.firstFamily().appendFamily(0);
1676         }
1677         fontDescription.setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
1678         int size = StyleResolver::fontSizeForKeyword(document, CSSValueMedium, false);
1679         fontDescription.setSpecifiedSize(size);
1680         bool useSVGZoomRules = document->isSVGDocument();
1681         fontDescription.setComputedSize(StyleResolver::getComputedSizeFromSpecifiedSize(document, documentStyle.get(), fontDescription.isAbsoluteSize(), size, useSVGZoomRules));
1682     }
1683
1684     documentStyle->setFontDescription(fontDescription);
1685     documentStyle->font().update(fontSelector);
1686
1687     return documentStyle.release();
1688 }
1689
1690 static inline bool isAtShadowBoundary(const Element* element)
1691 {
1692     if (!element)
1693         return false;
1694     ContainerNode* parentNode = element->parentNode();
1695     return parentNode && parentNode->isShadowRoot();
1696 }
1697
1698 PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderStyle* defaultParent,
1699     StyleSharingBehavior sharingBehavior, RuleMatchingBehavior matchingBehavior, RenderRegion* regionForStyling)
1700 {
1701     // Once an element has a renderer, we don't try to destroy it, since otherwise the renderer
1702     // will vanish if a style recalc happens during loading.
1703     if (sharingBehavior == AllowStyleSharing && !element->document()->haveStylesheetsLoaded() && !element->renderer()) {
1704         if (!s_styleNotYetAvailable) {
1705             s_styleNotYetAvailable = RenderStyle::create().leakRef();
1706             s_styleNotYetAvailable->setDisplay(NONE);
1707             s_styleNotYetAvailable->font().update(m_fontSelector);
1708         }
1709         element->document()->setHasNodesWithPlaceholderStyle();
1710         return s_styleNotYetAvailable;
1711     }
1712
1713     initElement(element);
1714     initForStyleResolve(element, defaultParent);
1715     m_regionForStyling = regionForStyling;
1716     if (sharingBehavior == AllowStyleSharing) {
1717         RenderStyle* sharedStyle = locateSharedStyle();
1718         if (sharedStyle)
1719             return sharedStyle;
1720     }
1721
1722     m_style = RenderStyle::create();
1723
1724     RefPtr<RenderStyle> cloneForParent;
1725
1726     if (m_parentStyle)
1727         m_style->inheritFrom(m_parentStyle, isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
1728     else {
1729         // Make sure our fonts are initialized if we don't inherit them from our parent style.
1730         if (Settings* settings = documentSettings()) {
1731             initializeFontStyle(settings);
1732             m_style->font().update(fontSelector());
1733         } else
1734             m_style->font().update(0);
1735         cloneForParent = RenderStyle::clone(style());
1736         m_parentStyle = cloneForParent.get();
1737     }
1738
1739     if (element->isLink()) {
1740         m_style->setIsLink(true);
1741         m_style->setInsideLink(m_elementLinkState);
1742     }
1743
1744     ensureDefaultStyleSheetsForElement(element);
1745
1746     MatchResult matchResult;
1747     if (matchingBehavior == MatchOnlyUserAgentRules)
1748         matchUARules(matchResult);
1749     else
1750         matchAllRules(matchResult, matchingBehavior != MatchAllRulesExcludingSMIL);
1751
1752     applyMatchedProperties(matchResult, element);
1753
1754     // Clean up our style object's display and text decorations (among other fixups).
1755     adjustRenderStyle(style(), m_parentStyle, element);
1756
1757     initElement(0); // Clear out for the next resolve.
1758
1759     if (cloneForParent)
1760         m_parentStyle = 0;
1761
1762     // Now return the style.
1763     return m_style.release();
1764 }
1765
1766 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(const RenderStyle* elementStyle, const StyleKeyframe* keyframe, KeyframeValue& keyframeValue)
1767 {
1768     MatchResult result;
1769     if (keyframe->properties())
1770         addMatchedProperties(result, keyframe->properties());
1771
1772     ASSERT(!m_style);
1773
1774     // Create the style
1775     m_style = RenderStyle::clone(elementStyle);
1776
1777     m_lineHeightValue = 0;
1778
1779     // We don't need to bother with !important. Since there is only ever one
1780     // decl, there's nothing to override. So just add the first properties.
1781     bool inheritedOnly = false;
1782     if (keyframe->properties())
1783         applyMatchedProperties<HighPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
1784
1785     // If our font got dirtied, go ahead and update it now.
1786     updateFont();
1787
1788     // Line-height is set when we are sure we decided on the font-size
1789     if (m_lineHeightValue)
1790         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
1791
1792     // Now do rest of the properties.
1793     if (keyframe->properties())
1794         applyMatchedProperties<LowPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
1795
1796     // If our font got dirtied by one of the non-essential font props,
1797     // go ahead and update it a second time.
1798     updateFont();
1799
1800     // Start loading resources referenced by this style.
1801     loadPendingResources();
1802     
1803     // Add all the animating properties to the keyframe.
1804     if (StylePropertySet* styleDeclaration = keyframe->properties()) {
1805         unsigned propertyCount = styleDeclaration->propertyCount();
1806         for (unsigned i = 0; i < propertyCount; ++i) {
1807             CSSPropertyID property = styleDeclaration->propertyAt(i).id();
1808             // Timing-function within keyframes is special, because it is not animated; it just
1809             // describes the timing function between this keyframe and the next.
1810             if (property != CSSPropertyWebkitAnimationTimingFunction)
1811                 keyframeValue.addProperty(property);
1812         }
1813     }
1814
1815     return m_style.release();
1816 }
1817
1818 void StyleResolver::keyframeStylesForAnimation(Element* e, const RenderStyle* elementStyle, KeyframeList& list)
1819 {
1820     list.clear();
1821
1822     // Get the keyframesRule for this name
1823     if (!e || list.animationName().isEmpty())
1824         return;
1825
1826     m_keyframesRuleMap.checkConsistency();
1827
1828     KeyframesRuleMap::iterator it = m_keyframesRuleMap.find(list.animationName().impl());
1829     if (it == m_keyframesRuleMap.end())
1830         return;
1831
1832     const StyleRuleKeyframes* keyframesRule = it->second.get();
1833
1834     // Construct and populate the style for each keyframe
1835     const Vector<RefPtr<StyleKeyframe> >& keyframes = keyframesRule->keyframes();
1836     for (unsigned i = 0; i < keyframes.size(); ++i) {
1837         // Apply the declaration to the style. This is a simplified version of the logic in styleForElement
1838         initElement(e);
1839         initForStyleResolve(e);
1840
1841         const StyleKeyframe* keyframe = keyframes[i].get();
1842
1843         KeyframeValue keyframeValue(0, 0);
1844         keyframeValue.setStyle(styleForKeyframe(elementStyle, keyframe, keyframeValue));
1845
1846         // Add this keyframe style to all the indicated key times
1847         Vector<float> keys;
1848         keyframe->getKeys(keys);
1849         for (size_t keyIndex = 0; keyIndex < keys.size(); ++keyIndex) {
1850             keyframeValue.setKey(keys[keyIndex]);
1851             list.insert(keyframeValue);
1852         }
1853     }
1854
1855     // If the 0% keyframe is missing, create it (but only if there is at least one other keyframe)
1856     int initialListSize = list.size();
1857     if (initialListSize > 0 && list[0].key()) {
1858         static StyleKeyframe* zeroPercentKeyframe;
1859         if (!zeroPercentKeyframe) {
1860             zeroPercentKeyframe = StyleKeyframe::create().leakRef();
1861             zeroPercentKeyframe->setKeyText("0%");
1862         }
1863         KeyframeValue keyframeValue(0, 0);
1864         keyframeValue.setStyle(styleForKeyframe(elementStyle, zeroPercentKeyframe, keyframeValue));
1865         list.insert(keyframeValue);
1866     }
1867
1868     // If the 100% keyframe is missing, create it (but only if there is at least one other keyframe)
1869     if (initialListSize > 0 && (list[list.size() - 1].key() != 1)) {
1870         static StyleKeyframe* hundredPercentKeyframe;
1871         if (!hundredPercentKeyframe) {
1872             hundredPercentKeyframe = StyleKeyframe::create().leakRef();
1873             hundredPercentKeyframe->setKeyText("100%");
1874         }
1875         KeyframeValue keyframeValue(1, 0);
1876         keyframeValue.setStyle(styleForKeyframe(elementStyle, hundredPercentKeyframe, keyframeValue));
1877         list.insert(keyframeValue);
1878     }
1879 }
1880
1881 PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(PseudoId pseudo, Element* e, RenderStyle* parentStyle)
1882 {
1883     if (!e)
1884         return 0;
1885
1886     initElement(e);
1887
1888     initForStyleResolve(e, parentStyle, pseudo);
1889     m_style = RenderStyle::create();
1890
1891     if (m_parentStyle)
1892         m_style->inheritFrom(m_parentStyle);
1893
1894     // Since we don't use pseudo-elements in any of our quirk/print user agent rules, don't waste time walking
1895     // those rules.
1896
1897     // Check UA, user and author rules.
1898     MatchResult matchResult;
1899     matchUARules(matchResult);
1900
1901     if (m_matchAuthorAndUserStyles) {
1902         matchUserRules(matchResult, false);
1903         matchAuthorRules(matchResult, false);
1904     }
1905
1906     if (matchResult.matchedProperties.isEmpty())
1907         return 0;
1908
1909     m_style->setStyleType(pseudo);
1910
1911     applyMatchedProperties(matchResult, e);
1912
1913     // Clean up our style object's display and text decorations (among other fixups).
1914     adjustRenderStyle(style(), parentStyle, 0);
1915
1916     // Start loading resources referenced by this style.
1917     loadPendingResources();
1918
1919     // Now return the style.
1920     return m_style.release();
1921 }
1922
1923 PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
1924 {
1925     initForStyleResolve(m_checker.document()->documentElement()); // m_rootElementStyle will be set to the document style.
1926
1927     m_style = RenderStyle::create();
1928     m_style->inheritFrom(m_rootElementStyle);
1929
1930     const bool isLeft = isLeftPage(pageIndex);
1931     const bool isFirst = isFirstPage(pageIndex);
1932     const String page = pageName(pageIndex);
1933     
1934     MatchResult result;
1935     matchPageRules(result, defaultPrintStyle, isLeft, isFirst, page);
1936     matchPageRules(result, m_userStyle.get(), isLeft, isFirst, page);
1937     // Only consider the global author RuleSet for @page rules, as per the HTML5 spec.
1938     matchPageRules(result, m_authorStyle.get(), isLeft, isFirst, page);
1939     m_lineHeightValue = 0;
1940     bool inheritedOnly = false;
1941 #if ENABLE(CSS_VARIABLES)
1942     applyMatchedProperties<VariableDefinitions>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
1943 #endif
1944     applyMatchedProperties<HighPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
1945
1946     // If our font got dirtied, go ahead and update it now.
1947     updateFont();
1948
1949     // Line-height is set when we are sure we decided on the font-size.
1950     if (m_lineHeightValue)
1951         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
1952
1953     applyMatchedProperties<LowPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
1954
1955     // Start loading resources referenced by this style.
1956     loadPendingResources();
1957
1958     // Now return the style.
1959     return m_style.release();
1960 }
1961
1962 static void addIntrinsicMargins(RenderStyle* style)
1963 {
1964     // Intrinsic margin value.
1965     const int intrinsicMargin = 2 * style->effectiveZoom();
1966
1967     // FIXME: Using width/height alone and not also dealing with min-width/max-width is flawed.
1968     // FIXME: Using "quirk" to decide the margin wasn't set is kind of lame.
1969     if (style->width().isIntrinsicOrAuto()) {
1970         if (style->marginLeft().quirk())
1971             style->setMarginLeft(Length(intrinsicMargin, Fixed));
1972         if (style->marginRight().quirk())
1973             style->setMarginRight(Length(intrinsicMargin, Fixed));
1974     }
1975
1976     if (style->height().isAuto()) {
1977         if (style->marginTop().quirk())
1978             style->setMarginTop(Length(intrinsicMargin, Fixed));
1979         if (style->marginBottom().quirk())
1980             style->setMarginBottom(Length(intrinsicMargin, Fixed));
1981     }
1982 }
1983
1984 static bool shouldBecomeBlockWhenParentIsFlexbox(const Element* element)
1985 {
1986     return element->hasTagName(imgTag)
1987         || element->hasTagName(canvasTag)
1988 #if ENABLE(SVG)
1989         || element->hasTagName(SVGNames::svgTag)
1990 #endif
1991 #if ENABLE(MATHML)
1992         || element->hasTagName(MathMLNames::mathTag)
1993 #endif
1994 #if ENABLE(VIDEO)
1995         || element->hasTagName(audioTag)
1996         || element->hasTagName(videoTag)
1997 #endif
1998         || element->hasTagName(iframeTag)
1999         || element->hasTagName(objectTag)
2000         || element->hasTagName(embedTag)
2001         || element->hasTagName(appletTag)
2002 #if ENABLE(PROGRESS_TAG)
2003         || element->hasTagName(progressTag)
2004 #endif
2005 #if ENABLE(METER_TAG)
2006         || element->hasTagName(meterTag)
2007 #endif
2008         || element->hasTagName(inputTag)
2009         || element->hasTagName(buttonTag)
2010         || element->hasTagName(selectTag)
2011         || element->hasTagName(textareaTag);
2012 }
2013
2014 static EDisplay equivalentBlockDisplay(EDisplay display, bool isFloating, bool strictParsing)
2015 {
2016     switch (display) {
2017     case BLOCK:
2018     case TABLE:
2019     case BOX:
2020 #if ENABLE(CSS3_FLEXBOX)
2021     case FLEX:
2022 #endif
2023     case GRID:
2024         return display;
2025
2026     case LIST_ITEM:
2027         // It is a WinIE bug that floated list items lose their bullets, so we'll emulate the quirk, but only in quirks mode.
2028         if (!strictParsing && isFloating)
2029             return BLOCK;
2030         return display;
2031     case INLINE_TABLE:
2032         return TABLE;
2033     case INLINE_BOX:
2034         return BOX;
2035 #if ENABLE(CSS3_FLEXBOX)
2036     case INLINE_FLEX:
2037         return FLEX;
2038 #endif
2039     case INLINE_GRID:
2040         return GRID;
2041
2042     case INLINE:
2043     case RUN_IN:
2044     case COMPACT:
2045     case INLINE_BLOCK:
2046     case TABLE_ROW_GROUP:
2047     case TABLE_HEADER_GROUP:
2048     case TABLE_FOOTER_GROUP:
2049     case TABLE_ROW:
2050     case TABLE_COLUMN_GROUP:
2051     case TABLE_COLUMN:
2052     case TABLE_CELL:
2053     case TABLE_CAPTION:
2054         return BLOCK;
2055     case NONE:
2056         ASSERT_NOT_REACHED();
2057         return NONE;
2058     }
2059     ASSERT_NOT_REACHED();
2060     return BLOCK;
2061 }
2062
2063 // CSS requires text-decoration to be reset at each DOM element for tables, 
2064 // inline blocks, inline tables, run-ins, shadow DOM crossings, floating elements,
2065 // and absolute or relatively positioned elements.
2066 static bool doesNotInheritTextDecoration(RenderStyle* style, Element* e)
2067 {
2068     return style->display() == TABLE || style->display() == INLINE_TABLE || style->display() == RUN_IN
2069         || style->display() == INLINE_BLOCK || style->display() == INLINE_BOX || isAtShadowBoundary(e)
2070         || style->isFloating() || style->isOutOfFlowPositioned();
2071 }
2072
2073 void StyleResolver::adjustRenderStyle(RenderStyle* style, RenderStyle* parentStyle, Element *e)
2074 {
2075     // Cache our original display.
2076     style->setOriginalDisplay(style->display());
2077
2078     if (style->display() != NONE) {
2079         // If we have a <td> that specifies a float property, in quirks mode we just drop the float
2080         // property.
2081         // Sites also commonly use display:inline/block on <td>s and <table>s. In quirks mode we force
2082         // these tags to retain their display types.
2083         if (!m_checker.strictParsing() && e) {
2084             if (e->hasTagName(tdTag)) {
2085                 style->setDisplay(TABLE_CELL);
2086                 style->setFloating(NoFloat);
2087             } else if (e->hasTagName(tableTag))
2088                 style->setDisplay(style->isDisplayInlineType() ? INLINE_TABLE : TABLE);
2089         }
2090
2091         if (e && (e->hasTagName(tdTag) || e->hasTagName(thTag))) {
2092             if (style->whiteSpace() == KHTML_NOWRAP) {
2093                 // Figure out if we are really nowrapping or if we should just
2094                 // use normal instead. If the width of the cell is fixed, then
2095                 // we don't actually use NOWRAP.
2096                 if (style->width().isFixed())
2097                     style->setWhiteSpace(NORMAL);
2098                 else
2099                     style->setWhiteSpace(NOWRAP);
2100             }
2101         }
2102
2103         // Tables never support the -webkit-* values for text-align and will reset back to the default.
2104         if (e && e->hasTagName(tableTag) && (style->textAlign() == WEBKIT_LEFT || style->textAlign() == WEBKIT_CENTER || style->textAlign() == WEBKIT_RIGHT))
2105             style->setTextAlign(TASTART);
2106
2107         // Frames and framesets never honor position:relative or position:absolute. This is necessary to
2108         // fix a crash where a site tries to position these objects. They also never honor display.
2109         if (e && (e->hasTagName(frameTag) || e->hasTagName(framesetTag))) {
2110             style->setPosition(StaticPosition);
2111             style->setDisplay(BLOCK);
2112         }
2113
2114         // Ruby text does not support float or position. This might change with evolution of the specification.
2115         if (e && e->hasTagName(rtTag)) {
2116             style->setPosition(StaticPosition);
2117             style->setFloating(NoFloat);
2118         }
2119
2120         // FIXME: We shouldn't be overriding start/-webkit-auto like this. Do it in html.css instead.
2121         // Table headers with a text-align of -webkit-auto will change the text-align to center.
2122         if (e && e->hasTagName(thTag) && style->textAlign() == TASTART)
2123             style->setTextAlign(CENTER);
2124
2125         if (e && e->hasTagName(legendTag))
2126             style->setDisplay(BLOCK);
2127
2128         // Absolute/fixed positioned elements, floating elements and the document element need block-like outside display.
2129         if (style->position() == AbsolutePosition || style->position() == FixedPosition || style->isFloating() || (e && e->document()->documentElement() == e))
2130             style->setDisplay(equivalentBlockDisplay(style->display(), style->isFloating(), m_checker.strictParsing()));
2131
2132         // FIXME: Don't support this mutation for pseudo styles like first-letter or first-line, since it's not completely
2133         // clear how that should work.
2134         if (style->display() == INLINE && style->styleType() == NOPSEUDO && parentStyle && style->writingMode() != parentStyle->writingMode())
2135             style->setDisplay(INLINE_BLOCK);
2136
2137         // After performing the display mutation, check table rows. We do not honor position:relative on
2138         // table rows or cells. This has been established in CSS2.1 (and caused a crash in containingBlock()
2139         // on some sites).
2140         if ((style->display() == TABLE_HEADER_GROUP || style->display() == TABLE_ROW_GROUP
2141              || style->display() == TABLE_FOOTER_GROUP || style->display() == TABLE_ROW)
2142              && style->position() == RelativePosition)
2143             style->setPosition(StaticPosition);
2144
2145         // writing-mode does not apply to table row groups, table column groups, table rows, and table columns.
2146         // FIXME: Table cells should be allowed to be perpendicular or flipped with respect to the table, though.
2147         if (style->display() == TABLE_COLUMN || style->display() == TABLE_COLUMN_GROUP || style->display() == TABLE_FOOTER_GROUP
2148             || style->display() == TABLE_HEADER_GROUP || style->display() == TABLE_ROW || style->display() == TABLE_ROW_GROUP
2149             || style->display() == TABLE_CELL)
2150             style->setWritingMode(parentStyle->writingMode());
2151
2152         // FIXME: Since we don't support block-flow on flexible boxes yet, disallow setting
2153         // of block-flow to anything other than TopToBottomWritingMode.
2154         // https://bugs.webkit.org/show_bug.cgi?id=46418 - Flexible box support.
2155         if (style->writingMode() != TopToBottomWritingMode && (style->display() == BOX || style->display() == INLINE_BOX))
2156             style->setWritingMode(TopToBottomWritingMode);
2157
2158         if (e && e->parentNode() && e->parentNode()->renderer() && e->parentNode()->renderer()->isFlexibleBox()) {
2159             if (shouldBecomeBlockWhenParentIsFlexbox(e))
2160                 style->setDisplay(BLOCK);
2161             else if (style->display() != INLINE)
2162                 style->setDisplay(equivalentBlockDisplay(style->display(), style->isFloating(), m_checker.strictParsing()));
2163         }
2164     }
2165
2166     // Make sure our z-index value is only applied if the object is positioned.
2167     if (style->position() == StaticPosition)
2168         style->setHasAutoZIndex();
2169
2170     // Auto z-index becomes 0 for the root element and transparent objects. This prevents
2171     // cases where objects that should be blended as a single unit end up with a non-transparent
2172     // object wedged in between them. Auto z-index also becomes 0 for objects that specify transforms/masks/reflections.
2173     if (style->hasAutoZIndex() && ((e && e->document()->documentElement() == e) || style->opacity() < 1.0f
2174         || style->hasTransformRelatedProperty() || style->hasMask() || style->boxReflect() || style->hasFilter()
2175 #ifdef FIXED_POSITION_CREATES_STACKING_CONTEXT
2176         || style->position() == FixedPosition
2177 #else
2178         || (style->position() == FixedPosition && e && e->document()->page() && e->document()->page()->settings()->fixedPositionCreatesStackingContext())
2179 #endif
2180 #if ENABLE(OVERFLOW_SCROLLING)
2181         // Touch overflow scrolling creates a stacking context.
2182         || ((style->overflowX() != OHIDDEN || style->overflowY() != OHIDDEN) && style->useTouchOverflowScrolling())
2183 #endif
2184         ))
2185         style->setZIndex(0);
2186
2187     // Textarea considers overflow visible as auto.
2188     if (e && e->hasTagName(textareaTag)) {
2189         style->setOverflowX(style->overflowX() == OVISIBLE ? OAUTO : style->overflowX());
2190         style->setOverflowY(style->overflowY() == OVISIBLE ? OAUTO : style->overflowY());
2191     }
2192
2193     if (doesNotInheritTextDecoration(style, e))
2194         style->setTextDecorationsInEffect(style->textDecoration());
2195     else
2196         style->addToTextDecorationsInEffect(style->textDecoration());
2197
2198     // If either overflow value is not visible, change to auto.
2199     if (style->overflowX() == OMARQUEE && style->overflowY() != OMARQUEE)
2200         style->setOverflowY(OMARQUEE);
2201     else if (style->overflowY() == OMARQUEE && style->overflowX() != OMARQUEE)
2202         style->setOverflowX(OMARQUEE);
2203     else if (style->overflowX() == OVISIBLE && style->overflowY() != OVISIBLE)
2204         style->setOverflowX(OAUTO);
2205     else if (style->overflowY() == OVISIBLE && style->overflowX() != OVISIBLE)
2206         style->setOverflowY(OAUTO);
2207
2208     // Table rows, sections and the table itself will support overflow:hidden and will ignore scroll/auto.
2209     // FIXME: Eventually table sections will support auto and scroll.
2210     if (style->display() == TABLE || style->display() == INLINE_TABLE
2211         || style->display() == TABLE_ROW_GROUP || style->display() == TABLE_ROW) {
2212         if (style->overflowX() != OVISIBLE && style->overflowX() != OHIDDEN)
2213             style->setOverflowX(OVISIBLE);
2214         if (style->overflowY() != OVISIBLE && style->overflowY() != OHIDDEN)
2215             style->setOverflowY(OVISIBLE);
2216     }
2217
2218     // Menulists should have visible overflow
2219     if (style->appearance() == MenulistPart) {
2220         style->setOverflowX(OVISIBLE);
2221         style->setOverflowY(OVISIBLE);
2222     }
2223
2224     // Cull out any useless layers and also repeat patterns into additional layers.
2225     style->adjustBackgroundLayers();
2226     style->adjustMaskLayers();
2227
2228     // Do the same for animations and transitions.
2229     style->adjustAnimations();
2230     style->adjustTransitions();
2231
2232     // Important: Intrinsic margins get added to controls before the theme has adjusted the style, since the theme will
2233     // alter fonts and heights/widths.
2234     if (e && e->isFormControlElement() && style->fontSize() >= 11) {
2235         // Don't apply intrinsic margins to image buttons. The designer knows how big the images are,
2236         // so we have to treat all image buttons as though they were explicitly sized.
2237         if (!e->hasTagName(inputTag) || !static_cast<HTMLInputElement*>(e)->isImageButton())
2238             addIntrinsicMargins(style);
2239     }
2240
2241     // Let the theme also have a crack at adjusting the style.
2242     if (style->hasAppearance())
2243         RenderTheme::defaultTheme()->adjustStyle(this, style, e, m_hasUAAppearance, m_borderData, m_backgroundData, m_backgroundColor);
2244
2245     // If we have first-letter pseudo style, do not share this style.
2246     if (style->hasPseudoStyle(FIRST_LETTER))
2247         style->setUnique();
2248
2249     // FIXME: when dropping the -webkit prefix on transform-style, we should also have opacity < 1 cause flattening.
2250     if (style->preserves3D() && (style->overflowX() != OVISIBLE
2251         || style->overflowY() != OVISIBLE
2252         || style->hasFilter()))
2253         style->setTransformStyle3D(TransformStyle3DFlat);
2254
2255     // Seamless iframes behave like blocks. Map their display to inline-block when marked inline.
2256     if (e && e->hasTagName(iframeTag) && style->display() == INLINE && static_cast<HTMLIFrameElement*>(e)->shouldDisplaySeamlessly())
2257         style->setDisplay(INLINE_BLOCK);
2258
2259 #if ENABLE(SVG)
2260     if (e && e->isSVGElement()) {
2261         // Spec: http://www.w3.org/TR/SVG/masking.html#OverflowProperty
2262         if (style->overflowY() == OSCROLL)
2263             style->setOverflowY(OHIDDEN);
2264         else if (style->overflowY() == OAUTO)
2265             style->setOverflowY(OVISIBLE);
2266
2267         if (style->overflowX() == OSCROLL)
2268             style->setOverflowX(OHIDDEN);
2269         else if (style->overflowX() == OAUTO)
2270             style->setOverflowX(OVISIBLE);
2271
2272         // Only the root <svg> element in an SVG document fragment tree honors css position
2273         if (!(e->hasTagName(SVGNames::svgTag) && e->parentNode() && !e->parentNode()->isSVGElement()))
2274             style->setPosition(RenderStyle::initialPosition());
2275
2276         // RenderSVGRoot handles zooming for the whole SVG subtree, so foreignObject content should
2277         // not be scaled again.
2278         if (e->hasTagName(SVGNames::foreignObjectTag))
2279             style->setEffectiveZoom(RenderStyle::initialZoom());
2280     }
2281 #endif
2282 }
2283
2284 bool StyleResolver::checkRegionStyle(Element* regionElement)
2285 {
2286     // FIXME (BUG 72472): We don't add @-webkit-region rules of scoped style sheets for the moment,
2287     // so all region rules are global by default. Verify whether that can stand or needs changing.
2288
2289     unsigned rulesSize = m_authorStyle->m_regionSelectorsAndRuleSets.size();
2290     for (unsigned i = 0; i < rulesSize; ++i) {
2291         ASSERT(m_authorStyle->m_regionSelectorsAndRuleSets.at(i).ruleSet.get());
2292         if (checkRegionSelector(m_authorStyle->m_regionSelectorsAndRuleSets.at(i).selector, regionElement))
2293             return true;
2294     }
2295
2296     if (m_userStyle) {
2297         rulesSize = m_userStyle->m_regionSelectorsAndRuleSets.size();
2298         for (unsigned i = 0; i < rulesSize; ++i) {
2299             ASSERT(m_userStyle->m_regionSelectorsAndRuleSets.at(i).ruleSet.get());
2300             if (checkRegionSelector(m_userStyle->m_regionSelectorsAndRuleSets.at(i).selector, regionElement))
2301                 return true;
2302         }
2303     }
2304
2305     return false;
2306 }
2307
2308 void StyleResolver::updateFont()
2309 {
2310     if (!m_fontDirty)
2311         return;
2312
2313     checkForTextSizeAdjust();
2314     checkForGenericFamilyChange(style(), m_parentStyle);
2315     checkForZoomChange(style(), m_parentStyle);
2316     m_style->font().update(m_fontSelector);
2317     m_fontDirty = false;
2318 }
2319
2320 void StyleResolver::cacheBorderAndBackground()
2321 {
2322     m_hasUAAppearance = m_style->hasAppearance();
2323     if (m_hasUAAppearance) {
2324         m_borderData = m_style->border();
2325         m_backgroundData = *m_style->backgroundLayers();
2326         m_backgroundColor = m_style->backgroundColor();
2327     }
2328 }
2329
2330 PassRefPtr<CSSRuleList> StyleResolver::styleRulesForElement(Element* e, unsigned rulesToInclude)
2331 {
2332     return pseudoStyleRulesForElement(e, NOPSEUDO, rulesToInclude);
2333 }
2334
2335 PassRefPtr<CSSRuleList> StyleResolver::pseudoStyleRulesForElement(Element* e, PseudoId pseudoId, unsigned rulesToInclude)
2336 {
2337     if (!e || !e->document()->haveStylesheetsLoaded())
2338         return 0;
2339
2340     m_checker.setMode(SelectorChecker::CollectingRules);
2341
2342     initElement(e);
2343     initForStyleResolve(e, 0, pseudoId);
2344
2345     MatchResult dummy;
2346     if (rulesToInclude & UAAndUserCSSRules) {
2347         // First we match rules from the user agent sheet.
2348         matchUARules(dummy);
2349
2350         // Now we check user sheet rules.
2351         if (m_matchAuthorAndUserStyles)
2352             matchUserRules(dummy, rulesToInclude & EmptyCSSRules);
2353     }
2354
2355     if (m_matchAuthorAndUserStyles && (rulesToInclude & AuthorCSSRules)) {
2356         m_sameOriginOnly = !(rulesToInclude & CrossOriginCSSRules);
2357
2358         // Check the rules in author sheets.
2359         matchAuthorRules(dummy, rulesToInclude & EmptyCSSRules);
2360
2361         m_sameOriginOnly = false;
2362     }
2363
2364     m_checker.setMode(SelectorChecker::ResolvingStyle);
2365
2366     return m_ruleList.release();
2367 }
2368
2369 inline bool StyleResolver::checkSelector(const RuleData& ruleData, const ContainerNode* scope)
2370 {
2371     m_dynamicPseudo = NOPSEUDO;
2372     m_checker.clearHasUnknownPseudoElements();
2373
2374     if (ruleData.hasFastCheckableSelector()) {
2375         // We know this selector does not include any pseudo elements.
2376         if (m_checker.pseudoStyle() != NOPSEUDO)
2377             return false;
2378         // We know a sufficiently simple single part selector matches simply because we found it from the rule hash.
2379         // This is limited to HTML only so we don't need to check the namespace.
2380         if (ruleData.hasRightmostSelectorMatchingHTMLBasedOnRuleHash() && m_element->isHTMLElement()) {
2381             if (!ruleData.hasMultipartSelector())
2382                 return true;
2383         } else if (!SelectorChecker::tagMatches(m_element, ruleData.selector()))
2384             return false;
2385         if (!SelectorChecker::fastCheckRightmostAttributeSelector(m_element, ruleData.selector()))
2386             return false;
2387         return m_checker.fastCheckSelector(ruleData.selector(), m_element);
2388     }
2389
2390     // Slow path.
2391     SelectorChecker::SelectorCheckingContext context(ruleData.selector(), m_element, SelectorChecker::VisitedMatchEnabled);
2392     context.elementStyle = style();
2393     context.elementParentStyle = m_parentNode ? m_parentNode->renderStyle() : 0;
2394     context.scope = scope;
2395     SelectorChecker::SelectorMatch match = m_checker.checkSelector(context, m_dynamicPseudo);
2396     if (match != SelectorChecker::SelectorMatches)
2397         return false;
2398     if (m_checker.pseudoStyle() != NOPSEUDO && m_checker.pseudoStyle() != m_dynamicPseudo)
2399         return false;
2400     return true;
2401 }
2402
2403 bool StyleResolver::checkRegionSelector(CSSSelector* regionSelector, Element* regionElement)
2404 {
2405     if (!regionSelector || !regionElement)
2406         return false;
2407
2408     m_checker.clearHasUnknownPseudoElements();
2409     m_checker.setPseudoStyle(NOPSEUDO);
2410
2411     for (CSSSelector* s = regionSelector; s; s = CSSSelectorList::next(s))
2412         if (m_checker.checkSelector(s, regionElement))
2413             return true;
2414
2415     return false;
2416 }
2417     
2418 bool StyleResolver::determineStylesheetSelectorScopes(StyleSheetContents* stylesheet, HashSet<AtomicStringImpl*>& idScopes, HashSet<AtomicStringImpl*>& classScopes)
2419 {
2420     ASSERT(!stylesheet->isLoading());
2421
2422     const Vector<RefPtr<StyleRuleImport> >& importRules = stylesheet->importRules();
2423     for (unsigned i = 0; i < importRules.size(); ++i) {
2424         if (!importRules[i]->styleSheet())
2425             continue;
2426         if (!determineStylesheetSelectorScopes(importRules[i]->styleSheet(), idScopes, classScopes))
2427             return false;
2428     }
2429
2430     const Vector<RefPtr<StyleRuleBase> >& rules = stylesheet->childRules();
2431     for (unsigned i = 0; i < rules.size(); i++) {
2432         StyleRuleBase* rule = rules[i].get();
2433         if (rule->isStyleRule()) {
2434             StyleRule* styleRule = static_cast<StyleRule*>(rule);
2435             if (!SelectorChecker::determineSelectorScopes(styleRule->selectorList(), idScopes, classScopes))
2436                 return false;
2437             continue;
2438         } 
2439         // FIXME: Media rules and maybe some others could be allowed.
2440         return false;
2441     }
2442     return true;
2443 }
2444
2445 // -----------------------------------------------------------------
2446
2447 static inline bool isSelectorMatchingHTMLBasedOnRuleHash(const CSSSelector* selector)
2448 {
2449     const AtomicString& selectorNamespace = selector->tag().namespaceURI();
2450     if (selectorNamespace != starAtom && selectorNamespace != xhtmlNamespaceURI)
2451         return false;
2452     if (selector->m_match == CSSSelector::None)
2453         return true;
2454     if (selector->tag() != starAtom)
2455         return false;
2456     if (SelectorChecker::isCommonPseudoClassSelector(selector))
2457         return true;
2458     return selector->m_match == CSSSelector::Id || selector->m_match == CSSSelector::Class;
2459 }
2460
2461 static inline bool selectorListContainsUncommonAttributeSelector(const CSSSelector* selector)
2462 {
2463     CSSSelectorList* selectorList = selector->selectorList();
2464     if (!selectorList)
2465         return false;
2466     for (CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
2467         if (subSelector->isAttributeSelector())
2468             return true;
2469     }
2470     return false;
2471 }
2472
2473 static inline bool isCommonAttributeSelectorAttribute(const QualifiedName& attribute)
2474 {
2475     // These are explicitly tested for equality in canShareStyleWithElement.
2476     return attribute == typeAttr || attribute == readonlyAttr;
2477 }
2478
2479 static inline bool containsUncommonAttributeSelector(const CSSSelector* selector)
2480 {
2481     for (; selector; selector = selector->tagHistory()) {
2482         // Allow certain common attributes (used in the default style) in the selectors that match the current element.
2483         if (selector->isAttributeSelector() && !isCommonAttributeSelectorAttribute(selector->attribute()))
2484             return true;
2485         if (selectorListContainsUncommonAttributeSelector(selector))
2486             return true;
2487         if (selector->relation() != CSSSelector::SubSelector) {
2488             selector = selector->tagHistory();
2489             break;
2490         }
2491     }
2492
2493     for (; selector; selector = selector->tagHistory()) {
2494         if (selector->isAttributeSelector())
2495             return true;
2496         if (selectorListContainsUncommonAttributeSelector(selector))
2497             return true;
2498     }
2499     return false;
2500 }
2501
2502 RuleData::RuleData(StyleRule* rule, CSSSelector* selector, unsigned position, bool hasDocumentSecurityOrigin, bool canUseFastCheckSelector, bool inRegionRule)
2503     : m_rule(rule)
2504     , m_selector(selector)
2505     , m_specificity(selector->specificity())
2506     , m_position(position)
2507     , m_hasFastCheckableSelector(canUseFastCheckSelector && SelectorChecker::isFastCheckableSelector(selector))
2508     , m_hasMultipartSelector(!!selector->tagHistory())
2509     , m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash(isSelectorMatchingHTMLBasedOnRuleHash(selector))
2510     , m_containsUncommonAttributeSelector(WebCore::containsUncommonAttributeSelector(selector))
2511     , m_linkMatchType(SelectorChecker::determineLinkMatchType(selector))
2512     , m_hasDocumentSecurityOrigin(hasDocumentSecurityOrigin)
2513     , m_isInRegionRule(inRegionRule)
2514 {
2515     SelectorChecker::collectIdentifierHashes(m_selector, m_descendantSelectorIdentifierHashes, maximumIdentifierCount);
2516 }
2517
2518 RuleSet::RuleSet()
2519     : m_ruleCount(0)
2520     , m_autoShrinkToFitEnabled(true)
2521 {
2522 }
2523
2524 static inline void collectFeaturesFromSelector(StyleResolver::Features& features, const CSSSelector* selector)
2525 {
2526     if (selector->m_match == CSSSelector::Id)
2527         features.idsInRules.add(selector->value().impl());
2528     if (selector->isAttributeSelector())
2529         features.attrsInRules.add(selector->attribute().localName().impl());
2530     switch (selector->pseudoType()) {
2531     case CSSSelector::PseudoFirstLine:
2532         features.usesFirstLineRules = true;
2533         break;
2534     case CSSSelector::PseudoBefore:
2535     case CSSSelector::PseudoAfter:
2536         features.usesBeforeAfterRules = true;
2537         break;
2538     case CSSSelector::PseudoLink:
2539     case CSSSelector::PseudoVisited:
2540         features.usesLinkRules = true;
2541         break;
2542     default:
2543         break;
2544     }
2545 }
2546
2547 static void collectFeaturesFromRuleData(StyleResolver::Features& features, const RuleData& ruleData)
2548 {
2549     bool foundSiblingSelector = false;
2550     for (CSSSelector* selector = ruleData.selector(); selector; selector = selector->tagHistory()) {
2551         collectFeaturesFromSelector(features, selector);
2552         
2553         if (CSSSelectorList* selectorList = selector->selectorList()) {
2554             for (CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
2555                 if (!foundSiblingSelector && selector->isSiblingSelector())
2556                     foundSiblingSelector = true;
2557                 collectFeaturesFromSelector(features, subSelector);
2558             }
2559         } else if (!foundSiblingSelector && selector->isSiblingSelector())
2560             foundSiblingSelector = true;
2561     }
2562     if (foundSiblingSelector)
2563         features.siblingRules.append(StyleResolver::RuleFeature(ruleData.rule(), ruleData.selector(), ruleData.hasDocumentSecurityOrigin()));
2564     if (ruleData.containsUncommonAttributeSelector())
2565         features.uncommonAttributeRules.append(StyleResolver::RuleFeature(ruleData.rule(), ruleData.selector(), ruleData.hasDocumentSecurityOrigin()));
2566 }
2567     
2568 void RuleSet::addToRuleSet(AtomicStringImpl* key, AtomRuleMap& map, const RuleData& ruleData)
2569 {
2570     if (!key)
2571         return;
2572     OwnPtr<Vector<RuleData> >& rules = map.add(key, nullptr).iterator->second;
2573     if (!rules)
2574         rules = adoptPtr(new Vector<RuleData>);
2575     rules->append(ruleData);
2576 }
2577
2578 void RuleSet::addRule(StyleRule* rule, CSSSelector* selector, bool hasDocumentSecurityOrigin, bool canUseFastCheckSelector, bool inRegionRule)
2579 {
2580     RuleData ruleData(rule, selector, m_ruleCount++, hasDocumentSecurityOrigin, canUseFastCheckSelector, inRegionRule);
2581     collectFeaturesFromRuleData(m_features, ruleData);
2582
2583     if (selector->m_match == CSSSelector::Id) {
2584         addToRuleSet(selector->value().impl(), m_idRules, ruleData);
2585         return;
2586     }
2587     if (selector->m_match == CSSSelector::Class) {
2588         addToRuleSet(selector->value().impl(), m_classRules, ruleData);
2589         return;
2590     }
2591     if (selector->isUnknownPseudoElement()) {
2592         addToRuleSet(selector->value().impl(), m_shadowPseudoElementRules, ruleData);
2593         return;
2594     }
2595     if (SelectorChecker::isCommonPseudoClassSelector(selector)) {
2596         switch (selector->pseudoType()) {
2597         case CSSSelector::PseudoLink:
2598         case CSSSelector::PseudoVisited:
2599         case CSSSelector::PseudoAnyLink:
2600             m_linkPseudoClassRules.append(ruleData);
2601             return;
2602         case CSSSelector::PseudoFocus:
2603             m_focusPseudoClassRules.append(ruleData);
2604             return;
2605         default:
2606             ASSERT_NOT_REACHED();
2607         }
2608         return;
2609     }
2610     const AtomicString& localName = selector->tag().localName();
2611     if (localName != starAtom) {
2612         addToRuleSet(localName.impl(), m_tagRules, ruleData);
2613         return;
2614     }
2615     m_universalRules.append(ruleData);
2616 }
2617
2618 void RuleSet::addPageRule(StyleRulePage* rule)
2619 {
2620     m_pageRules.append(rule);
2621 }
2622
2623 void RuleSet::addRegionRule(StyleRuleRegion* regionRule, bool hasDocumentSecurityOrigin)
2624 {
2625     OwnPtr<RuleSet> regionRuleSet = RuleSet::create();
2626     // The region rule set should take into account the position inside the parent rule set.
2627     // Otherwise, the rules inside region block might be incorrectly positioned before other similar rules from
2628     // the stylesheet that contains the region block.
2629     regionRuleSet->m_ruleCount = m_ruleCount;
2630
2631     // Collect the region rules into a rule set
2632     const Vector<RefPtr<StyleRuleBase> >& childRules = regionRule->childRules();
2633     for (unsigned i = 0; i < childRules.size(); ++i) {
2634         StyleRuleBase* regionStylingRule = childRules[i].get();
2635         if (regionStylingRule->isStyleRule())
2636             regionRuleSet->addStyleRule(static_cast<StyleRule*>(regionStylingRule), hasDocumentSecurityOrigin, true, true);
2637     }
2638     // Update the "global" rule count so that proper order is maintained
2639     m_ruleCount = regionRuleSet->m_ruleCount;
2640
2641     m_regionSelectorsAndRuleSets.append(RuleSetSelectorPair(regionRule->selectorList().first(), regionRuleSet.release()));
2642 }
2643
2644 void RuleSet::addRulesFromSheet(StyleSheetContents* sheet, const MediaQueryEvaluator& medium, StyleResolver* styleSelector, const ContainerNode* scope)
2645 {
2646     ASSERT(sheet);
2647     
2648     const Vector<RefPtr<StyleRuleImport> >& importRules = sheet->importRules();
2649     for (unsigned i = 0; i < importRules.size(); ++i) {
2650         StyleRuleImport* importRule = importRules[i].get();
2651         if (importRule->styleSheet() && (!importRule->mediaQueries() || medium.eval(importRule->mediaQueries(), styleSelector)))
2652             addRulesFromSheet(importRule->styleSheet(), medium, styleSelector, scope);
2653     }
2654     bool hasDocumentSecurityOrigin = styleSelector && styleSelector->document()->securityOrigin()->canRequest(sheet->baseURL());
2655
2656     const Vector<RefPtr<StyleRuleBase> >& rules = sheet->childRules();
2657     for (unsigned i = 0; i < rules.size(); ++i) {
2658         StyleRuleBase* rule = rules[i].get();
2659
2660         ASSERT(!rule->isImportRule());
2661         if (rule->isStyleRule())
2662             addStyleRule(static_cast<StyleRule*>(rule), hasDocumentSecurityOrigin, !scope);
2663         else if (rule->isPageRule())
2664             addPageRule(static_cast<StyleRulePage*>(rule));
2665         else if (rule->isMediaRule()) {
2666             StyleRuleMedia* mediaRule = static_cast<StyleRuleMedia*>(rule);
2667
2668             if ((!mediaRule->mediaQueries() || medium.eval(mediaRule->mediaQueries(), styleSelector))) {
2669                 // Traverse child elements of the @media rule.
2670                 const Vector<RefPtr<StyleRuleBase> >& childRules = mediaRule->childRules();
2671                 for (unsigned j = 0; j < childRules.size(); ++j) {
2672                     StyleRuleBase* childRule = childRules[j].get();
2673                     if (childRule->isStyleRule())
2674                         addStyleRule(static_cast<StyleRule*>(childRule), hasDocumentSecurityOrigin, !scope);
2675                     else if (childRule->isPageRule())
2676                         addPageRule(static_cast<StyleRulePage*>(childRule));
2677                     else if (childRule->isFontFaceRule() && styleSelector) {
2678                         // Add this font face to our set.
2679                         // FIXME(BUG 72461): We don't add @font-face rules of scoped style sheets for the moment.
2680                         if (scope)
2681                             continue;
2682                         const StyleRuleFontFace* fontFaceRule = static_cast<StyleRuleFontFace*>(childRule);
2683                         styleSelector->fontSelector()->addFontFaceRule(fontFaceRule);
2684                         styleSelector->invalidateMatchedPropertiesCache();
2685                     } else if (childRule->isKeyframesRule() && styleSelector) {
2686                         // Add this keyframe rule to our set.
2687                         // FIXME(BUG 72462): We don't add @keyframe rules of scoped style sheets for the moment.
2688                         if (scope)
2689                             continue;
2690                         styleSelector->addKeyframeStyle(static_cast<StyleRuleKeyframes*>(childRule));
2691                     }
2692                 } // for rules
2693             } // if rules
2694         } else if (rule->isFontFaceRule() && styleSelector) {
2695             // Add this font face to our set.
2696             // FIXME(BUG 72461): We don't add @font-face rules of scoped style sheets for the moment.
2697             if (scope)
2698                 continue;
2699             const StyleRuleFontFace* fontFaceRule = static_cast<StyleRuleFontFace*>(rule);
2700             styleSelector->fontSelector()->addFontFaceRule(fontFaceRule);
2701             styleSelector->invalidateMatchedPropertiesCache();
2702         } else if (rule->isKeyframesRule() && styleSelector) {
2703             // FIXME (BUG 72462): We don't add @keyframe rules of scoped style sheets for the moment.
2704             if (scope)
2705                 continue;
2706             styleSelector->addKeyframeStyle(static_cast<StyleRuleKeyframes*>(rule));
2707         }
2708 #if ENABLE(CSS_REGIONS)
2709         else if (rule->isRegionRule() && styleSelector) {
2710             // FIXME (BUG 72472): We don't add @-webkit-region rules of scoped style sheets for the moment.
2711             if (scope)
2712                 continue;
2713             addRegionRule(static_cast<StyleRuleRegion*>(rule), hasDocumentSecurityOrigin);
2714         }
2715 #endif
2716     }
2717     if (m_autoShrinkToFitEnabled)
2718         shrinkToFit();
2719 }
2720
2721 void RuleSet::addStyleRule(StyleRule* rule, bool hasDocumentSecurityOrigin, bool canUseFastCheckSelector, bool isInRegionRule)
2722 {
2723     for (CSSSelector* s = rule->selectorList().first(); s; s = CSSSelectorList::next(s))
2724         addRule(rule, s, hasDocumentSecurityOrigin, canUseFastCheckSelector, isInRegionRule);
2725 }
2726
2727 static inline void shrinkMapVectorsToFit(RuleSet::AtomRuleMap& map)
2728 {
2729     RuleSet::AtomRuleMap::iterator end = map.end();
2730     for (RuleSet::AtomRuleMap::iterator it = map.begin(); it != end; ++it)
2731         it->second->shrinkToFit();
2732 }
2733
2734 void RuleSet::shrinkToFit()
2735 {
2736     shrinkMapVectorsToFit(m_idRules);
2737     shrinkMapVectorsToFit(m_classRules);
2738     shrinkMapVectorsToFit(m_tagRules);
2739     shrinkMapVectorsToFit(m_shadowPseudoElementRules);
2740     m_linkPseudoClassRules.shrinkToFit();
2741     m_focusPseudoClassRules.shrinkToFit();
2742     m_universalRules.shrinkToFit();
2743     m_pageRules.shrinkToFit();
2744 }
2745
2746 // -------------------------------------------------------------------------------------
2747 // this is mostly boring stuff on how to apply a certain rule to the renderstyle...
2748
2749 Length StyleResolver::convertToIntLength(CSSPrimitiveValue* primitiveValue, RenderStyle* style, RenderStyle* rootStyle, double multiplier)
2750 {
2751     return primitiveValue ? primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
2752 }
2753
2754 Length StyleResolver::convertToFloatLength(CSSPrimitiveValue* primitiveValue, RenderStyle* style, RenderStyle* rootStyle, double multiplier)
2755 {
2756     return primitiveValue ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
2757 }
2758
2759 template <StyleResolver::StyleApplicationPass pass>
2760 void StyleResolver::applyProperties(const StylePropertySet* properties, StyleRule* rule, bool isImportant, bool inheritedOnly, bool filterRegionProperties)
2761 {
2762     ASSERT(!filterRegionProperties || m_regionForStyling);
2763     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willProcessRule(document(), rule);
2764
2765     unsigned propertyCount = properties->propertyCount();
2766     for (unsigned i = 0; i < propertyCount; ++i) {
2767         const CSSProperty& current = properties->propertyAt(i);
2768         if (isImportant != current.isImportant())
2769             continue;
2770         if (inheritedOnly && !current.isInherited()) {
2771             // If the property value is explicitly inherited, we need to apply further non-inherited properties
2772             // as they might override the value inherited here. For this reason we don't allow declarations with
2773             // explicitly inherited properties to be cached.
2774             ASSERT(!current.value()->isInheritedValue());
2775             continue;
2776         }
2777         CSSPropertyID property = current.id();
2778
2779         if (filterRegionProperties && !StyleResolver::isValidRegionStyleProperty(property))
2780             continue;
2781
2782         switch (pass) {
2783 #if ENABLE(CSS_VARIABLES)
2784         case VariableDefinitions:
2785             COMPILE_ASSERT(CSSPropertyVariable < firstCSSProperty, CSS_variable_is_before_first_property);
2786             if (property == CSSPropertyVariable)
2787                 applyProperty(current.id(), current.value());
2788             break;
2789 #endif
2790         case HighPriorityProperties:
2791             COMPILE_ASSERT(firstCSSProperty == CSSPropertyColor, CSS_color_is_first_property);
2792             COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 18, CSS_zoom_is_end_of_first_prop_range);
2793             COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyZoom + 1, CSS_line_height_is_after_zoom);
2794 #if ENABLE(CSS_VARIABLES)
2795             if (property == CSSPropertyVariable)
2796                 continue;
2797 #endif
2798             // give special priority to font-xxx, color properties, etc
2799             if (property < CSSPropertyLineHeight)
2800                 applyProperty(current.id(), current.value());
2801             // we apply line-height later
2802             else if (property == CSSPropertyLineHeight)
2803                 m_lineHeightValue = current.value();
2804             break;
2805         case LowPriorityProperties:
2806             if (property > CSSPropertyLineHeight)
2807                 applyProperty(current.id(), current.value());
2808         }
2809     }
2810     InspectorInstrumentation::didProcessRule(cookie);
2811 }
2812
2813 template <StyleResolver::StyleApplicationPass pass>
2814 void StyleResolver::applyMatchedProperties(const MatchResult& matchResult, bool isImportant, int startIndex, int endIndex, bool inheritedOnly)
2815 {
2816     if (startIndex == -1)
2817         return;
2818
2819     if (m_style->insideLink() != NotInsideLink) {
2820         for (int i = startIndex; i <= endIndex; ++i) {
2821             const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
2822             unsigned linkMatchType = matchedProperties.linkMatchType;
2823             // FIXME: It would be nicer to pass these as arguments but that requires changes in many places.
2824             m_applyPropertyToRegularStyle = linkMatchType & SelectorChecker::MatchLink;
2825             m_applyPropertyToVisitedLinkStyle = linkMatchType & SelectorChecker::MatchVisited;
2826
2827             applyProperties<pass>(matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, matchedProperties.isInRegionRule);
2828         }
2829         m_applyPropertyToRegularStyle = true;
2830         m_applyPropertyToVisitedLinkStyle = false;
2831         return;
2832     }
2833     for (int i = startIndex; i <= endIndex; ++i) {
2834         const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
2835         applyProperties<pass>(matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, matchedProperties.isInRegionRule);
2836     }
2837 }
2838
2839 unsigned StyleResolver::computeMatchedPropertiesHash(const MatchedProperties* properties, unsigned size)
2840 {
2841     
2842     return StringHasher::hashMemory(properties, sizeof(MatchedProperties) * size);
2843 }
2844
2845 bool operator==(const StyleResolver::MatchRanges& a, const StyleResolver::MatchRanges& b)
2846 {
2847     return a.firstUARule == b.firstUARule
2848         && a.lastUARule == b.lastUARule
2849         && a.firstAuthorRule == b.firstAuthorRule
2850         && a.lastAuthorRule == b.lastAuthorRule
2851         && a.firstUserRule == b.firstUserRule
2852         && a.lastUserRule == b.lastUserRule;
2853 }
2854
2855 bool operator!=(const StyleResolver::MatchRanges& a, const StyleResolver::MatchRanges& b)
2856 {
2857     return !(a == b);
2858 }
2859
2860 bool operator==(const StyleResolver::MatchedProperties& a, const StyleResolver::MatchedProperties& b)
2861 {
2862     return a.properties == b.properties && a.linkMatchType == b.linkMatchType;
2863 }
2864
2865 bool operator!=(const StyleResolver::MatchedProperties& a, const StyleResolver::MatchedProperties& b)
2866 {
2867     return !(a == b);
2868 }
2869
2870 const StyleResolver::MatchedPropertiesCacheItem* StyleResolver::findFromMatchedPropertiesCache(unsigned hash, const MatchResult& matchResult)
2871 {
2872     ASSERT(hash);
2873
2874     MatchedPropertiesCache::iterator it = m_matchedPropertiesCache.find(hash);
2875     if (it == m_matchedPropertiesCache.end())
2876         return 0;
2877     MatchedPropertiesCacheItem& cacheItem = it->second;
2878
2879     size_t size = matchResult.matchedProperties.size();
2880     if (size != cacheItem.matchedProperties.size())
2881         return 0;
2882     for (size_t i = 0; i < size; ++i) {
2883         if (matchResult.matchedProperties[i] != cacheItem.matchedProperties[i])
2884             return 0;
2885     }
2886     if (cacheItem.ranges != matchResult.ranges)
2887         return 0;
2888     return &cacheItem;
2889 }
2890
2891 void StyleResolver::addToMatchedPropertiesCache(const RenderStyle* style, const RenderStyle* parentStyle, unsigned hash, const MatchResult& matchResult)
2892 {
2893     static unsigned matchedDeclarationCacheAdditionsBetweenSweeps = 100;
2894     if (++m_matchedPropertiesCacheAdditionsSinceLastSweep >= matchedDeclarationCacheAdditionsBetweenSweeps) {
2895         sweepMatchedPropertiesCache();
2896         m_matchedPropertiesCacheAdditionsSinceLastSweep = 0;
2897     }
2898
2899     ASSERT(hash);
2900     MatchedPropertiesCacheItem cacheItem;
2901     cacheItem.matchedProperties.append(matchResult.matchedProperties);
2902     cacheItem.ranges = matchResult.ranges;
2903     // Note that we don't cache the original RenderStyle instance. It may be further modified.
2904     // The RenderStyle in the cache is really just a holder for the substructures and never used as-is.
2905     cacheItem.renderStyle = RenderStyle::clone(style);
2906     cacheItem.parentRenderStyle = RenderStyle::clone(parentStyle);
2907     m_matchedPropertiesCache.add(hash, cacheItem);
2908 }
2909
2910 void StyleResolver::invalidateMatchedPropertiesCache()
2911 {
2912     m_matchedPropertiesCache.clear();
2913 }
2914
2915 static bool isCacheableInMatchedPropertiesCache(const Element* element, const RenderStyle* style, const RenderStyle* parentStyle)
2916 {
2917     // FIXME: CSSPropertyWebkitWritingMode modifies state when applying to document element. We can't skip the applying by caching.
2918     if (element == element->document()->documentElement() && element->document()->writingModeSetOnDocumentElement())
2919         return false;
2920     if (style->unique() || (style->styleType() != NOPSEUDO && parentStyle->unique()))
2921         return false;
2922     if (style->hasAppearance())
2923         return false;
2924     if (style->zoom() != RenderStyle::initialZoom())
2925         return false;
2926     // The cache assumes static knowledge about which properties are inherited.
2927     if (parentStyle->hasExplicitlyInheritedProperties())
2928         return false;
2929     return true;
2930 }
2931
2932 void StyleResolver::applyMatchedProperties(const MatchResult& matchResult, const Element* element)
2933 {
2934     ASSERT(element);
2935     unsigned cacheHash = matchResult.isCacheable ? computeMatchedPropertiesHash(matchResult.matchedProperties.data(), matchResult.matchedProperties.size()) : 0;
2936     bool applyInheritedOnly = false;
2937     const MatchedPropertiesCacheItem* cacheItem = 0;
2938     if (cacheHash && (cacheItem = findFromMatchedPropertiesCache(cacheHash, matchResult))) {
2939         // We can build up the style by copying non-inherited properties from an earlier style object built using the same exact
2940         // style declarations. We then only need to apply the inherited properties, if any, as their values can depend on the 
2941         // element context. This is fast and saves memory by reusing the style data structures.
2942         m_style->copyNonInheritedFrom(cacheItem->renderStyle.get());
2943         if (m_parentStyle->inheritedDataShared(cacheItem->parentRenderStyle.get()) && !isAtShadowBoundary(element)) {
2944             EInsideLink linkStatus = m_style->insideLink();
2945             // If the cache item parent style has identical inherited properties to the current parent style then the
2946             // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
2947             m_style->inheritFrom(cacheItem->renderStyle.get());
2948
2949             // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
2950             m_style->setInsideLink(linkStatus);
2951             return;
2952         }
2953         applyInheritedOnly = true; 
2954     }
2955
2956 #if ENABLE(CSS_VARIABLES)
2957     // First apply all variable definitions, as they may be used during application of later properties.
2958     applyMatchedProperties<VariableDefinitions>(matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
2959     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
2960     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
2961     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
2962 #endif
2963
2964     // Now we have all of the matched rules in the appropriate order. Walk the rules and apply
2965     // high-priority properties first, i.e., those properties that other properties depend on.
2966     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
2967     // and (4) normal important.
2968     m_lineHeightValue = 0;
2969     applyMatchedProperties<HighPriorityProperties>(matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
2970     applyMatchedProperties<HighPriorityProperties>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
2971     applyMatchedProperties<HighPriorityProperties>(matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
2972     applyMatchedProperties<HighPriorityProperties>(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
2973
2974     if (cacheItem && cacheItem->renderStyle->effectiveZoom() != m_style->effectiveZoom()) {
2975         m_fontDirty = true;
2976         applyInheritedOnly = false;
2977     }
2978
2979     // If our font got dirtied, go ahead and update it now.
2980     updateFont();
2981
2982     // Line-height is set when we are sure we decided on the font-size.
2983     if (m_lineHeightValue)
2984         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
2985
2986     // Many properties depend on the font. If it changes we just apply all properties.
2987     if (cacheItem && cacheItem->renderStyle->fontDescription() != m_style->fontDescription())
2988         applyInheritedOnly = false;
2989
2990     // Now do the normal priority UA properties.
2991     applyMatchedProperties<LowPriorityProperties>(matchResult, false, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
2992     
2993     // Cache our border and background so that we can examine them later.
2994     cacheBorderAndBackground();
2995     
2996     // Now do the author and user normal priority properties and all the !important properties.
2997     applyMatchedProperties<LowPriorityProperties>(matchResult, false, matchResult.ranges.lastUARule + 1, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
2998     applyMatchedProperties<LowPriorityProperties>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
2999     applyMatchedProperties<LowPriorityProperties>(matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
3000     applyMatchedProperties<LowPriorityProperties>(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
3001    
3002     // Start loading resources referenced by this style.
3003     loadPendingResources();
3004     
3005     ASSERT(!m_fontDirty);
3006     
3007     if (cacheItem || !cacheHash)
3008         return;
3009     if (!isCacheableInMatchedPropertiesCache(m_element, m_style.get(), m_parentStyle))
3010         return;
3011     addToMatchedPropertiesCache(m_style.get(), m_parentStyle, cacheHash, matchResult);
3012 }
3013
3014 static inline bool comparePageRules(const StyleRulePage* r1, const StyleRulePage* r2)
3015 {
3016     return r1->selector()->specificity() < r2->selector()->specificity();
3017 }
3018
3019 void StyleResolver::matchPageRules(MatchResult& result, RuleSet* rules, bool isLeftPage, bool isFirstPage, const String& pageName)
3020 {
3021     if (!rules)
3022         return;
3023
3024     Vector<StyleRulePage*> matchedPageRules;
3025     matchPageRulesForList(matchedPageRules, rules->pageRules(), isLeftPage, isFirstPage, pageName);
3026     if (matchedPageRules.isEmpty())
3027         return;
3028
3029     std::stable_sort(matchedPageRules.begin(), matchedPageRules.end(), comparePageRules);
3030
3031     for (unsigned i = 0; i < matchedPageRules.size(); i++)
3032         addMatchedProperties(result, matchedPageRules[i]->properties());
3033 }
3034
3035 void StyleResolver::matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>& rules, bool isLeftPage, bool isFirstPage, const String& pageName)
3036 {
3037     unsigned size = rules.size();
3038     for (unsigned i = 0; i < size; ++i) {
3039         StyleRulePage* rule = rules[i];
3040         const AtomicString& selectorLocalName = rule->selector()->tag().localName();
3041         if (selectorLocalName != starAtom && selectorLocalName != pageName)
3042             continue;
3043         CSSSelector::PseudoType pseudoType = rule->selector()->pseudoType();
3044         if ((pseudoType == CSSSelector::PseudoLeftPage && !isLeftPage)
3045             || (pseudoType == CSSSelector::PseudoRightPage && isLeftPage)
3046             || (pseudoType == CSSSelector::PseudoFirstPage && !isFirstPage))
3047             continue;
3048
3049         // If the rule has no properties to apply, then ignore it.
3050         const StylePropertySet* properties = rule->properties();
3051         if (!properties || properties->isEmpty())
3052             continue;
3053
3054         // Add this rule to our list of matched rules.
3055         matchedRules.append(rule);
3056     }
3057 }
3058
3059 bool StyleResolver::isLeftPage(int pageIndex) const
3060 {
3061     bool isFirstPageLeft = false;
3062     if (!m_rootElementStyle->isLeftToRightDirection())
3063         isFirstPageLeft = true;
3064
3065     return (pageIndex + (isFirstPageLeft ? 1 : 0)) % 2;
3066 }
3067
3068 bool StyleResolver::isFirstPage(int pageIndex) const
3069 {
3070     // FIXME: In case of forced left/right page, page at index 1 (not 0) can be the first page.
3071     return (!pageIndex);
3072 }
3073
3074 String StyleResolver::pageName(int /* pageIndex */) const
3075 {
3076     // FIXME: Implement page index to page name mapping.
3077     return "";
3078 }
3079
3080 template <class ListType>
3081 static void collectCSSOMWrappers(HashMap<StyleRule*, RefPtr<CSSStyleRule> >& wrapperMap, ListType* listType)
3082 {
3083     if (!listType)
3084         return;
3085     unsigned size = listType->length();
3086     for (unsigned i = 0; i < size; ++i) {
3087         CSSRule* cssRule = listType->item(i);
3088         if (cssRule->isImportRule())
3089             collectCSSOMWrappers(wrapperMap, static_cast<CSSImportRule*>(cssRule)->styleSheet());
3090         else if (cssRule->isMediaRule())
3091             collectCSSOMWrappers(wrapperMap, static_cast<CSSMediaRule*>(cssRule));
3092 #if ENABLE(CSS_REGIONS)
3093         else if (cssRule->isRegionRule())
3094             collectCSSOMWrappers(wrapperMap, static_cast<WebKitCSSRegionRule*>(cssRule));
3095 #endif
3096         else if (cssRule->isStyleRule()) {
3097             CSSStyleRule* cssStyleRule = static_cast<CSSStyleRule*>(cssRule);
3098             wrapperMap.add(cssStyleRule->styleRule(), cssStyleRule);
3099         }
3100     }
3101 }
3102
3103 static void collectCSSOMWrappers(HashMap<StyleRule*, RefPtr<CSSStyleRule> >& wrapperMap, HashSet<RefPtr<CSSStyleSheet> >& sheetWrapperSet, StyleSheetContents* styleSheet)
3104 {
3105     if (!styleSheet)
3106         return;
3107     RefPtr<CSSStyleSheet> styleSheetWrapper = CSSStyleSheet::create(styleSheet);
3108     sheetWrapperSet.add(styleSheetWrapper);
3109     collectCSSOMWrappers(wrapperMap, styleSheetWrapper.get());
3110 }
3111
3112 static void collectCSSOMWrappers(HashMap<StyleRule*, RefPtr<CSSStyleRule> >& wrapperMap, Document* document)
3113 {
3114     const Vector<RefPtr<StyleSheet> >& styleSheets = document->styleSheets()->vector();
3115     for (unsigned i = 0; i < styleSheets.size(); ++i) {
3116         StyleSheet* styleSheet = styleSheets[i].get();
3117         if (!styleSheet->isCSSStyleSheet())
3118             continue;
3119         collectCSSOMWrappers(wrapperMap, static_cast<CSSStyleSheet*>(styleSheet));
3120     }
3121     collectCSSOMWrappers(wrapperMap, document->pageUserSheet());
3122     {
3123         const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets = document->pageGroupUserSheets();
3124         if (pageGroupUserSheets) {
3125             for (size_t i = 0, size = pageGroupUserSheets->size(); i < size; ++i)
3126                 collectCSSOMWrappers(wrapperMap, pageGroupUserSheets->at(i).get());
3127         }
3128     }
3129     {
3130         const Vector<RefPtr<CSSStyleSheet> >* documentUserSheets = document->documentUserSheets();
3131         if (documentUserSheets) {
3132             for (size_t i = 0, size = documentUserSheets->size(); i < size; ++i)
3133                 collectCSSOMWrappers(wrapperMap, documentUserSheets->at(i).get());
3134         }
3135     }
3136 }
3137
3138 CSSStyleRule* StyleResolver::ensureFullCSSOMWrapperForInspector(StyleRule* rule)
3139 {
3140     if (m_styleRuleToCSSOMWrapperMap.isEmpty()) {
3141         collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, m_styleSheetCSSOMWrapperSet, simpleDefaultStyleSheet);
3142         collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, m_styleSheetCSSOMWrapperSet, defaultStyleSheet);
3143         collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, m_styleSheetCSSOMWrapperSet, quirksStyleSheet);
3144         collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, m_styleSheetCSSOMWrapperSet, svgStyleSheet);
3145         collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, m_styleSheetCSSOMWrapperSet, mathMLStyleSheet);
3146         collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, m_styleSheetCSSOMWrapperSet, mediaControlsStyleSheet);
3147         collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, m_styleSheetCSSOMWrapperSet, fullscreenStyleSheet);
3148
3149         collectCSSOMWrappers(m_styleRuleToCSSOMWrapperMap, document());
3150     }
3151     return m_styleRuleToCSSOMWrapperMap.get(rule).get();
3152 }
3153
3154 void StyleResolver::applyPropertyToStyle(CSSPropertyID id, CSSValue* value, RenderStyle* style)
3155 {
3156     initElement(0);
3157     initForStyleResolve(0, style);
3158     m_style = style;
3159     applyPropertyToCurrentStyle(id, value);
3160 }
3161
3162 void StyleResolver::applyPropertyToCurrentStyle(CSSPropertyID id, CSSValue* value)
3163 {
3164     if (value)
3165         applyProperty(id, value);
3166 }
3167
3168 inline bool isValidVisitedLinkProperty(CSSPropertyID id)
3169 {
3170     switch (id) {
3171     case CSSPropertyBackgroundColor:
3172     case CSSPropertyBorderLeftColor:
3173     case CSSPropertyBorderRightColor:
3174     case CSSPropertyBorderTopColor:
3175     case CSSPropertyBorderBottomColor:
3176     case CSSPropertyColor:
3177     case CSSPropertyOutlineColor:
3178     case CSSPropertyWebkitColumnRuleColor:
3179     case CSSPropertyWebkitTextEmphasisColor:
3180     case CSSPropertyWebkitTextFillColor:
3181     case CSSPropertyWebkitTextStrokeColor:
3182     // Also allow shorthands so that inherit/initial still work.
3183     case CSSPropertyBackground:
3184     case CSSPropertyBorderLeft:
3185     case CSSPropertyBorderRight:
3186     case CSSPropertyBorderTop:
3187     case CSSPropertyBorderBottom:
3188     case CSSPropertyOutline:
3189     case CSSPropertyWebkitColumnRule:
3190 #if ENABLE(SVG)
3191     case CSSPropertyFill:
3192     case CSSPropertyStroke:
3193 #endif
3194         return true;
3195     default:
3196         break;
3197     }
3198
3199     return false;
3200 }
3201
3202 // http://dev.w3.org/csswg/css3-regions/#the-at-region-style-rule
3203 // FIXME: add incremental support for other region styling properties.
3204 inline bool StyleResolver::isValidRegionStyleProperty(CSSPropertyID id)
3205 {
3206     switch (id) {
3207     case CSSPropertyBackgroundColor:
3208     case CSSPropertyColor:
3209         return true;
3210     default:
3211         break;
3212     }
3213
3214     return false;
3215 }
3216
3217 // SVG handles zooming in a different way compared to CSS. The whole document is scaled instead
3218 // of each individual length value in the render style / tree. CSSPrimitiveValue::computeLength*()
3219 // multiplies each resolved length with the zoom multiplier - so for SVG we need to disable that.
3220 // Though all CSS values that can be applied to outermost <svg> elements (width/height/border/padding...)
3221 // need to respect the scaling. RenderBox (the parent class of RenderSVGRoot) grabs values like
3222 // width/height/border/padding/... from the RenderStyle -> for SVG these values would never scale,
3223 // if we'd pass a 1.0 zoom factor everyhwere. So we only pass a zoom factor of 1.0 for specific
3224 // properties that are NOT allowed to scale within a zoomed SVG document (letter/word-spacing/font-size).
3225 bool StyleResolver::useSVGZoomRules()
3226 {
3227     return m_element && m_element->isSVGElement();
3228 }
3229
3230 static bool createGridTrackBreadth(CSSPrimitiveValue* primitiveValue, StyleResolver* selector, Length& length)
3231 {
3232     Length workingLength = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | ViewportPercentageConversion | AutoConversion>(selector->style(), selector->rootElementStyle(), selector->style()->effectiveZoom());
3233     if (workingLength.isUndefined())
3234         return false;
3235
3236     if (primitiveValue->isLength())
3237         workingLength.setQuirk(primitiveValue->isQuirkValue());
3238
3239     length = workingLength;
3240     return true;
3241 }
3242
3243 static bool createGridTrackList(CSSValue* value, Vector<Length>& lengths, StyleResolver* selector)
3244 {
3245     // Handle 'none'.
3246     if (value->isPrimitiveValue()) {
3247         CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
3248         if (primitiveValue->getIdent() == CSSValueNone) {
3249             lengths.append(Length(Undefined));
3250             return true;
3251         }
3252         return false;
3253     }
3254
3255     if (value->isValueList()) {
3256         for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
3257             CSSValue* currValue = i.value();
3258             if (!currValue->isPrimitiveValue())
3259                 return false;
3260
3261             Length length;
3262             if (!createGridTrackBreadth(static_cast<CSSPrimitiveValue*>(currValue), selector, length))
3263                 return false;
3264
3265             lengths.append(length);
3266         }
3267         return true;
3268     }
3269
3270     return false;
3271 }
3272
3273
3274 static bool createGridPosition(CSSValue* value, Length& position)
3275 {
3276     // For now, we only accept: <integer> | 'auto'
3277     if (!value->isPrimitiveValue())
3278         return false;
3279
3280     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
3281     if (primitiveValue->getIdent() == CSSValueAuto)
3282         return true;
3283
3284     ASSERT(primitiveValue->isNumber());
3285     position.setValue(primitiveValue->getIntValue());
3286     return true;
3287 }
3288
3289 #if ENABLE(CSS_VARIABLES)
3290 static bool hasVariableReference(CSSValue* value)
3291 {
3292     if (value->isPrimitiveValue() && static_cast<CSSPrimitiveValue*>(value)->isVariableName())
3293         return true;
3294
3295     for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
3296         if (hasVariableReference(i.value()))
3297             return true;
3298     }
3299
3300     return false;
3301 }
3302
3303 void StyleResolver::resolveVariables(CSSPropertyID id, CSSValue* value, Vector<std::pair<CSSPropertyID, String> >& knownExpressions)
3304 {
3305     std::pair<CSSPropertyID, String> expression(id, value->serializeResolvingVariables(*style()->variables()));
3306
3307     if (knownExpressions.contains(expression))
3308         return; // cycle detected.
3309
3310     knownExpressions.append(expression);
3311
3312     // FIXME: It would be faster not to re-parse from strings, but for now CSS property validation lives inside the parser so we do it there.
3313     RefPtr<StylePropertySet> resultSet = StylePropertySet::create();
3314     if (!CSSParser::parseValue(resultSet.get(), id, expression.second, false, document()))
3315         return; // expression failed to parse.
3316
3317     for (unsigned i = 0; i < resultSet->propertyCount(); i++) {
3318         const CSSProperty& property = resultSet->propertyAt(i);
3319         if (property.id() != CSSPropertyVariable && hasVariableReference(property.value()))
3320             resolveVariables(property.id(), property.value(), knownExpressions);
3321         else
3322             applyProperty(property.id(), property.value());
3323     }
3324 }
3325 #endif
3326
3327 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value)
3328 {
3329 #if ENABLE(CSS_VARIABLES)
3330     if (id != CSSPropertyVariable && hasVariableReference(value)) {
3331         Vector<std::pair<CSSPropertyID, String> > knownExpressions;
3332         resolveVariables(id, value, knownExpressions);
3333         return;
3334     }
3335 #endif
3336
3337     bool isInherit = m_parentNode && value->isInheritedValue();
3338     bool isInitial = value->isInitialValue() || (!m_parentNode && value->isInheritedValue());
3339
3340     ASSERT(!isInherit || !isInitial); // isInherit -> !isInitial && isInitial -> !isInherit
3341
3342     if (!applyPropertyToRegularStyle() && (!applyPropertyToVisitedLinkStyle() || !isValidVisitedLinkProperty(id))) {
3343         // Limit the properties that can be applied to only the ones honored by :visited.
3344         return;
3345     }
3346
3347     if (isInherit && m_parentStyle && !m_parentStyle->hasExplicitlyInheritedProperties() && !CSSProperty::isInheritedProperty(id))
3348         m_parentStyle->setHasExplicitlyInheritedProperties();
3349
3350 #if ENABLE(CSS_VARIABLES)
3351     if (id == CSSPropertyVariable) {
3352         ASSERT(value->isVariableValue());
3353         CSSVariableValue* variable = static_cast<CSSVariableValue*>(value);
3354         ASSERT(!variable->name().isEmpty());
3355         ASSERT(!variable->value().isEmpty());
3356         m_style->setVariable(variable->name(), variable->value());
3357         return;
3358     }
3359 #endif
3360
3361     // Check lookup table for implementations and use when available.
3362     const PropertyHandler& handler = m_styleBuilder.propertyHandler(id);
3363     if (handler.isValid()) {
3364         if (isInherit)
3365             handler.applyInheritValue(this);
3366         else if (isInitial)
3367             handler.applyInitialValue(this);
3368         else
3369             handler.applyValue(this, value);
3370         return;
3371     }
3372
3373     CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? static_cast<CSSPrimitiveValue*>(value) : 0;
3374
3375     float zoomFactor = m_style->effectiveZoom();
3376
3377     // What follows is a list that maps the CSS properties into their corresponding front-end
3378     // RenderStyle values. Shorthands (e.g. border, background) occur in this list as well and
3379     // are only hit when mapping "inherit" or "initial" into front-end values.
3380     switch (id) {
3381     // lists
3382     case CSSPropertyContent:
3383         // list of string, uri, counter, attr, i
3384         {
3385             // FIXME: In CSS3, it will be possible to inherit content. In CSS2 it is not. This
3386             // note is a reminder that eventually "inherit" needs to be supported.
3387
3388             if (isInitial) {
3389                 m_style->clearContent();
3390                 return;
3391             }
3392
3393             if (!value->isValueList())
3394                 return;
3395
3396             bool didSet = false;
3397             for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
3398                 CSSValue* item = i.value();
3399                 if (item->isImageGeneratorValue()) {
3400                     m_style->setContent(StyleGeneratedImage::create(static_cast<CSSImageGeneratorValue*>(item)), didSet);
3401                     didSet = true;
3402 #if ENABLE(CSS_IMAGE_SET)
3403                 } else if (item->isImageSetValue()) {
3404                     m_style->setContent(setOrPendingFromValue(CSSPropertyContent, static_cast<CSSImageSetValue*>(item)), didSet);
3405                     didSet = true;
3406 #endif
3407                 }
3408
3409                 if (item->isImageValue()) {
3410                     m_style->setContent(cachedOrPendingFromValue(CSSPropertyContent, static_cast<CSSImageValue*>(item)), didSet);
3411                     didSet = true;
3412                     continue;
3413                 }
3414
3415                 if (!item->isPrimitiveValue())
3416                     continue;
3417
3418                 CSSPrimitiveValue* contentValue = static_cast<CSSPrimitiveValue*>(item);
3419
3420                 if (contentValue->isString()) {
3421                     m_style->setContent(contentValue->getStringValue().impl(), didSet);
3422                     didSet = true;
3423                 } else if (contentValue->isAttr()) {
3424                     // FIXME: Can a namespace be specified for an attr(foo)?
3425                     if (m_style->styleType() == NOPSEUDO)
3426                         m_style->setUnique();
3427                     else
3428                         m_parentStyle->setUnique();
3429                     QualifiedName attr(nullAtom, contentValue->getStringValue().impl(), nullAtom);
3430                     const AtomicString& value = m_element->getAttribute(attr);
3431                     m_style->setContent(value.isNull() ? emptyAtom : value.impl(), didSet);
3432                     didSet = true;
3433                     // register the fact that the attribute value affects the style
3434                     m_features.attrsInRules.add(attr.localName().impl());
3435                 } else if (contentValue->isCounter()) {
3436                     Counter* counterValue = contentValue->getCounterValue();
3437                     EListStyleType listStyleType = NoneListStyle;
3438                     int listStyleIdent = counterValue->listStyleIdent();
3439                     if (listStyleIdent != CSSValueNone)
3440                         listStyleType = static_cast<EListStyleType>(listStyleIdent - CSSValueDisc);
3441                     OwnPtr<CounterContent> counter = adoptPtr(new CounterContent(counterValue->identifier(), listStyleType, counterValue->separator()));
3442                     m_style->setContent(counter.release(), didSet);
3443                     didSet = true;
3444                 } else {
3445                     switch (contentValue->getIdent()) {
3446                     case CSSValueOpenQuote:
3447                         m_style->setContent(OPEN_QUOTE, didSet);
3448                         didSet = true;
3449                         break;
3450                     case CSSValueCloseQuote:
3451                         m_style->setContent(CLOSE_QUOTE, didSet);
3452                         didSet = true;
3453                         break;
3454                     case CSSValueNoOpenQuote:
3455                         m_style->setContent(NO_OPEN_QUOTE, didSet);
3456                         didSet = true;
3457                         break;
3458                     case CSSValueNoCloseQuote:
3459                         m_style->setContent(NO_CLOSE_QUOTE, didSet);
3460                         didSet = true;
3461                         break;
3462                     default:
3463                         // normal and none do not have any effect.
3464                         { }
3465                     }
3466                 }
3467             }
3468             if (!didSet)
3469                 m_style->clearContent();
3470             return;
3471         }
3472     case CSSPropertyQuotes:
3473         if (isInherit) {
3474             if (m_parentStyle)
3475                 m_style->setQuotes(m_parentStyle->quotes());
3476             return;
3477         }
3478         if (isInitial) {
3479             m_style->setQuotes(0);
3480             return;
3481         }
3482         if (value->isValueList()) {
3483             CSSValueList* list = static_cast<CSSValueList*>(value);
3484             QuotesData* data = QuotesData::create(list->length());
3485             if (!data)
3486                 return; // Out of memory
3487             String* quotes = data->data();
3488             for (CSSValueListIterator i = list; i.hasMore(); i.advance()) {
3489                 CSSValue* item = i.value();
3490                 ASSERT(item->isPrimitiveValue());
3491                 primitiveValue = static_cast<CSSPrimitiveValue*>(item);
3492                 ASSERT(primitiveValue->isString());
3493                 quotes[i.index()] = primitiveValue->getStringValue();
3494             }
3495             m_style->setQuotes(adoptRef(data));
3496         } else if (primitiveValue) {
3497             ASSERT(primitiveValue->isIdent());
3498             if (primitiveValue->getIdent() == CSSValueNone)
3499                 m_style->setQuotes(adoptRef(QuotesData::create(0)));
3500         }
3501         return;
3502     case CSSPropertyFontFamily: {
3503         // list of strings and ids
3504         if (isInherit) {
3505             FontDescription parentFontDescription = m_parentStyle->fontDescription();
3506             FontDescription fontDescription = m_style->fontDescription();
3507             fontDescription.setGenericFamily(parentFontDescription.genericFamily());
3508             fontDescription.setFamily(parentFontDescription.firstFamily());
3509             fontDescription.setIsSpecifiedFont(parentFontDescription.isSpecifiedFont());
3510             setFontDescription(fontDescription);
3511             return;
3512         }
3513
3514         if (isInitial) {
3515             FontDescription initialDesc = FontDescription();
3516             FontDescription fontDescription = m_style->fontDescription();
3517             // We need to adjust the size to account for the generic family change from monospace
3518             // to non-monospace.
3519             if (fontDescription.keywordSize() && fontDescription.useFixedDefaultSize())
3520                 setFontSize(fontDescription, fontSizeForKeyword(m_checker.document(), CSSValueXxSmall + fontDescription.keywordSize() - 1, false));
3521             fontDescription.setGenericFamily(initialDesc.genericFamily());
3522             if (!initialDesc.firstFamily().familyIsEmpty())
3523                 fontDescription.setFamily(initialDesc.firstFamily());
3524             setFontDescription(fontDescription);
3525             return;
3526         }
3527
3528         if (!value->isValueList())
3529             return;
3530         FontDescription fontDescription = m_style->fontDescription();
3531         FontFamily& firstFamily = fontDescription.firstFamily();
3532         FontFamily* currFamily = 0;
3533
3534         // Before mapping in a new font-family property, we should reset the generic family.
3535         bool oldFamilyUsedFixedDefaultSize = fontDescription.useFixedDefaultSize();
3536         fontDescription.setGenericFamily(FontDescription::NoFamily);
3537
3538         for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
3539             CSSValue* item = i.value();
3540             if (!item->isPrimitiveValue())
3541                 continue;
3542             CSSPrimitiveValue* contentValue = static_cast<CSSPrimitiveValue*>(item);
3543             AtomicString face;
3544             Settings* settings = documentSettings();
3545             if (contentValue->isString())
3546                 face = contentValue->getStringValue();
3547             else if (settings) {
3548                 switch (contentValue->getIdent()) {
3549                 case CSSValueWebkitBody:
3550                     face = settings->standardFontFamily();
3551                     break;
3552                 case CSSValueSerif:
3553                     face = serifFamily;
3554                     fontDescription.setGenericFamily(FontDescription::SerifFamily);
3555                     break;
3556                 case CSSValueSansSerif:
3557                     face = sansSerifFamily;
3558                     fontDescription.setGenericFamily(FontDescription::SansSerifFamily);
3559                     break;
3560                 case CSSValueCursive:
3561                     face = cursiveFamily;
3562                     fontDescription.setGenericFamily(FontDescription::CursiveFamily);
3563                     break;
3564                 case CSSValueFantasy:
3565                     face = fantasyFamily;
3566                     fontDescription.setGenericFamily(FontDescription::FantasyFamily);
3567                     break;
3568                 case CSSValueMonospace:
3569                     face = monospaceFamily;
3570                     fontDescription.setGenericFamily(FontDescription::MonospaceFamily);
3571                     break;
3572                 case CSSValueWebkitPictograph:
3573                     face = pictographFamily;
3574                     fontDescription.setGenericFamily(FontDescription::PictographFamily);
3575                     break;
3576                 }
3577             }
3578
3579             if (!face.isEmpty()) {
3580                 if (!currFamily) {
3581                     // Filling in the first family.
3582                     firstFamily.setFamily(face);
3583                     firstFamily.appendFamily(0); // Remove any inherited family-fallback list.
3584                     currFamily = &firstFamily;
3585                     fontDescription.setIsSpecifiedFont(fontDescription.genericFamily() == FontDescription::NoFamily);
3586                 } else {
3587                     RefPtr<SharedFontFamily> newFamily = SharedFontFamily::create();
3588                     newFamily->setFamily(face);
3589                     currFamily->appendFamily(newFamily);
3590                     currFamily = newFamily.get();
3591                 }
3592             }
3593         }
3594
3595         // We can't call useFixedDefaultSize() until all new font families have been added
3596         // If currFamily is non-zero then we set at least one family on this description.
3597         if (currFamily) {
3598             if (fontDescription.keywordSize() && fontDescription.useFixedDefaultSize() != oldFamilyUsedFixedDefaultSize)
3599                 setFontSize(fontDescription, fontSizeForKeyword(m_checker.document(), CSSValueXxSmall + fontDescription.keywordSize() - 1, !oldFamilyUsedFixedDefaultSize));
3600
3601             setFontDescription(fontDescription);
3602         }
3603         return;
3604     }
3605 // shorthand properties
3606     case CSSPropertyBackground:
3607         if (isInitial) {
3608             m_style->clearBackgroundLayers();
3609             m_style->setBackgroundColor(Color());
3610         } else if (isInherit) {
3611             m_style->inheritBackgroundLayers(*m_parentStyle->backgroundLayers());
3612             m_style->setBackgroundColor(m_parentStyle->backgroundColor());
3613         }
3614         return;
3615     case CSSPropertyWebkitMask:
3616         if (isInitial)
3617             m_style->clearMaskLayers();
3618         else if (isInherit)
3619             m_style->inheritMaskLayers(*m_parentStyle->maskLayers());
3620         return;
3621     case CSSPropertyFont:
3622         if (isInherit) {
3623             FontDescription fontDescription = m_parentStyle->fontDescription();
3624             m_style->setLineHeight(m_parentStyle->lineHeight());
3625             m_lineHeightValue = 0;
3626             setFontDescription(fontDescription);
3627         } else if (isInitial) {
3628             Settings* settings = documentSettings();
3629             ASSERT(settings); // If we're doing style resolution, this document should always be in a frame and thus have settings
3630             if (!settings)
3631                 return;
3632             initializeFontStyle(settings);
3633         } else if (primitiveValue) {
3634             m_style->setLineHeight(RenderStyle::initialLineHeight());
3635             m_lineHeightValue = 0;
3636
3637             FontDescription fontDescription;
3638             RenderTheme::defaultTheme()->systemFont(primitiveValue->getIdent(), fontDescription);
3639
3640             // Double-check and see if the theme did anything. If not, don't bother updating the font.
3641             if (fontDescription.isAbsoluteSize()) {
3642                 // Make sure the rendering mode and printer font settings are updated.
3643                 Settings* settings = documentSettings();
3644                 ASSERT(settings); // If we're doing style resolution, this document should always be in a frame and thus have settings
3645                 if (!settings)
3646                     return;
3647                 fontDescription.setRenderingMode(settings->fontRenderingMode());
3648                 fontDescription.setUsePrinterFont(m_checker.document()->printing());
3649
3650                 // Handle the zoom factor.
3651                 fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(m_checker.document(), m_style.get(), fontDescription.isAbsoluteSize(), fontDescription.specifiedSize(), useSVGZoomRules()));
3652                 setFontDescription(fontDescription);
3653             }
3654         } else if (value->isFontValue()) {
3655             FontValue* font = static_cast<FontValue*>(value);
3656             if (!font->style || !font->variant || !font->weight
3657                 || !font->size || !font->lineHeight || !font->family)
3658                 return;
3659             applyProperty(CSSPropertyFontStyle, font->style.get());
3660             applyProperty(CSSPropertyFontVariant, font->variant.get());
3661             applyProperty(CSSPropertyFontWeight, font->weight.get());
3662             // The previous properties can dirty our font but they don't try to read the font's
3663             // properties back, which is safe. However if font-size is using the 'ex' unit, it will
3664             // need query the dirtied font's x-height to get the computed size. To be safe in this
3665             // case, let's just update the font now.
3666             updateFont();
3667             applyProperty(CSSPropertyFontSize, font->size.get());
3668
3669             m_lineHeightValue = font->lineHeight.get();
3670
3671             applyProperty(CSSPropertyFontFamily, font->family.get());
3672         }
3673         return;
3674
3675     // CSS3 Properties
3676     case CSSPropertyTextShadow:
3677     case CSSPropertyBoxShadow:
3678     case CSSPropertyWebkitBoxShadow: {
3679         if (isInherit) {
3680             if (id == CSSPropertyTextShadow)
3681                 return m_style->setTextShadow(m_parentStyle->textShadow() ? adoptPtr(new ShadowData(*m_parentStyle->textShadow())) : nullptr);
3682             return m_style->setBoxShadow(m_parentStyle->boxShadow() ? adoptPtr(new ShadowData(*m_parentStyle->boxShadow())) : nullptr);
3683         }
3684         if (isInitial || primitiveValue) // initial | none
3685             return id == CSSPropertyTextShadow ? m_style->setTextShadow(nullptr) : m_style->setBoxShadow(nullptr);
3686
3687         if (!value->isValueList())
3688             return;
3689
3690         for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
3691             CSSValue* currValue = i.value();
3692             if (!currValue->isShadowValue())
3693                 continue;
3694             ShadowValue* item = static_cast<ShadowValue*>(currValue);
3695             int x = item->x->computeLength<int>(style(), m_rootElementStyle, zoomFactor);
3696             int y = item->y->computeLength<int>(style(), m_rootElementStyle, zoomFactor);
3697             int blur = item->blur ? item->blur->computeLength<int>(style(), m_rootElementStyle, zoomFactor) : 0;
3698             int spread = item->spread ? item->spread->computeLength<int>(style(), m_rootElementStyle, zoomFactor) : 0;
3699             ShadowStyle shadowStyle = item->style && item->style->getIdent() == CSSValueInset ? Inset : Normal;
3700             Color color;
3701             if (item->color)
3702                 color = colorFromPrimitiveValue(item->color.get());
3703             else if (m_style)
3704                 color = m_style->color();
3705
3706             OwnPtr<ShadowData> shadowData = adoptPtr(new ShadowData(IntPoint(x, y), blur, spread, shadowStyle, id == CSSPropertyWebkitBoxShadow, color.isValid() ? color : Color::transparent));
3707             if (id == CSSPropertyTextShadow)
3708                 m_style->setTextShadow(shadowData.release(), i.index()); // add to the list if this is not the first entry
3709             else
3710                 m_style->setBoxShadow(shadowData.release(), i.index()); // add to the list if this is not the first entry
3711         }
3712         return;
3713     }
3714     case CSSPropertyWebkitBoxReflect: {
3715         HANDLE_INHERIT_AND_INITIAL(boxReflect, BoxReflect)
3716         if (primitiveValue) {
3717             m_style->setBoxReflect(RenderStyle::initialBoxReflect());
3718             return;
3719         }
3720
3721         if (!value->isReflectValue())
3722             return;
3723
3724         CSSReflectValue* reflectValue = static_cast<CSSReflectValue*>(value);
3725         RefPtr<StyleReflection> reflection = StyleReflection::create();
3726         reflection->setDirection(reflectValue->direction());
3727         if (reflectValue->offset())
3728             reflection->setOffset(reflectValue->offset()->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(style(), m_rootElementStyle, zoomFactor));
3729         NinePieceImage mask;
3730         mask.setMaskDefaults();
3731         m_styleMap.mapNinePieceImage(id, reflectValue->mask(), mask);
3732         reflection->setMask(mask);
3733
3734         m_style->setBoxReflect(reflection.release());
3735         return;
3736     }
3737     case CSSPropertyOpacity:
3738         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(opacity, Opacity)
3739         return;
3740     case CSSPropertySrc: // Only used in @font-face rules.
3741         return;
3742     case CSSPropertyUnicodeRange: // Only used in @font-face rules.
3743         return;
3744     case CSSPropertyWebkitColumnRule:
3745         if (isInherit) {
3746             m_style->setColumnRuleColor(m_parentStyle->columnRuleColor().isValid() ? m_parentStyle->columnRuleColor() : m_parentStyle->color());
3747             m_style->setColumnRuleStyle(m_parentStyle->columnRuleStyle());
3748             m_style->setColumnRuleWidth(m_parentStyle->columnRuleWidth());
3749         } else if (isInitial)
3750             m_style->resetColumnRule();
3751         return;
3752     case CSSPropertyWebkitMarquee:
3753         if (!m_parentNode || !value->isInheritedValue())
3754             return;
3755         m_style->setMarqueeDirection(m_parentStyle->marqueeDirection());
3756         m_style->setMarqueeIncrement(m_parentStyle->marqueeIncrement());
3757         m_style->setMarqueeSpeed(m_parentStyle->marqueeSpeed());
3758         m_style->setMarqueeLoopCount(m_parentStyle->marqueeLoopCount());
3759         m_style->setMarqueeBehavior(m_parentStyle->marqueeBehavior());
3760         return;
3761     case CSSPropertyWebkitMarqueeRepetition: {
3762         HANDLE_INHERIT_AND_INITIAL(marqueeLoopCount, MarqueeLoopCount)
3763         if (!primitiveValue)
3764             return;
3765         if (primitiveValue->getIdent() == CSSValueInfinite)
3766             m_style->setMarqueeLoopCount(-1); // -1 means repeat forever.
3767         else if (primitiveValue->isNumber())
3768             m_style->setMarqueeLoopCount(primitiveValue->getIntValue());
3769         return;
3770     }
3771     case CSSPropertyWebkitMarqueeSpeed: {
3772         HANDLE_INHERIT_AND_INITIAL(marqueeSpeed, MarqueeSpeed)
3773         if (!primitiveValue)
3774             return;
3775         if (int ident = primitiveValue->getIdent()) {
3776             switch (ident) {
3777             case CSSValueSlow:
3778                 m_style->setMarqueeSpeed(500); // 500 msec.
3779                 break;
3780             case CSSValueNormal:
3781                 m_style->setMarqueeSpeed(85); // 85msec. The WinIE default.
3782                 break;
3783             case CSSValueFast:
3784                 m_style->setMarqueeSpeed(10); // 10msec. Super fast.
3785                 break;
3786             }
3787         } else if (primitiveValue->isTime())
3788             m_style->setMarqueeSpeed(primitiveValue->computeTime<int, CSSPrimitiveValue::Milliseconds>());
3789         else if (primitiveValue->isNumber()) // For scrollamount support.
3790             m_style->setMarqueeSpeed(primitiveValue->getIntValue());
3791         return;
3792     }
3793     case CSSPropertyWebkitMarqueeIncrement: {
3794         HANDLE_INHERIT_AND_INITIAL(marqueeIncrement, MarqueeIncrement)
3795         if (!primitiveValue)
3796             return;
3797         if (primitiveValue->getIdent()) {
3798             switch (primitiveValue->getIdent()) {
3799             case CSSValueSmall:
3800                 m_style->setMarqueeIncrement(Length(1, Fixed)); // 1px.
3801                 break;
3802             case CSSValueNormal:
3803                 m_style->setMarqueeIncrement(Length(6, Fixed)); // 6px. The WinIE default.
3804                 break;
3805             case CSSValueLarge:
3806                 m_style->setMarqueeIncrement(Length(36, Fixed)); // 36px.
3807                 break;
3808             }
3809         } else {
3810             Length marqueeLength = convertToIntLength(primitiveValue, style(), m_rootElementStyle);
3811             if (!marqueeLength.isUndefined())
3812                 m_style->setMarqueeIncrement(marqueeLength);
3813         }
3814         return;
3815     }
3816     case CSSPropertyWebkitLineClamp:
3817         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(lineClamp, LineClamp)
3818         return;
3819     case CSSPropertyWebkitLocale: {
3820         HANDLE_INHERIT_AND_INITIAL(locale, Locale);
3821         if (!primitiveValue)
3822             return;
3823         if (primitiveValue->getIdent() == CSSValueAuto)
3824             m_style->setLocale(nullAtom);
3825         else
3826             m_style->setLocale(primitiveValue->getStringValue());
3827         FontDescription fontDescription = m_style->fontDescription();
3828         fontDescription.setScript(localeToScriptCodeForFontSelection(m_style->locale()));
3829         setFontDescription(fontDescription);
3830         return;
3831     }
3832     case CSSPropertyWebkitTextSizeAdjust: {
3833         HANDLE_INHERIT_AND_INITIAL(textSizeAdjust, TextSizeAdjust)
3834         if (!primitiveValue || !primitiveValue->getIdent())
3835             return;
3836         setTextSizeAdjust(primitiveValue->getIdent() == CSSValueAuto);
3837         return;
3838     }
3839 #if ENABLE(DASHBOARD_SUPPORT)
3840     case CSSPropertyWebkitDashboardRegion: {
3841         HANDLE_INHERIT_AND_INITIAL(dashboardRegions, DashboardRegions)
3842         if (!primitiveValue)
3843             return;
3844
3845         if (primitiveValue->getIdent() == CSSValueNone) {
3846             m_style->setDashboardRegions(RenderStyle::noneDashboardRegions());
3847             return;
3848         }
3849
3850         DashboardRegion* region = primitiveValue->getDashboardRegionValue();
3851         if (!region)
3852             return;
3853
3854         DashboardRegion* first = region;
3855         while (region) {
3856             Length top = convertToIntLength(region->top(), style(), m_rootElementStyle);
3857             Length right = convertToIntLength(region->right(), style(), m_rootElementStyle);
3858             Length bottom = convertToIntLength(region->bottom(), style(), m_rootElementStyle);
3859             Length left = convertToIntLength(region->left(), style(), m_rootElementStyle);
3860
3861             if (top.isUndefined())
3862                 top = Length();
3863             if (right.isUndefined())
3864                 right = Length();
3865             if (bottom.isUndefined())
3866                 bottom = Length();
3867             if (left.isUndefined())
3868                 left = Length();
3869
3870             if (region->m_isCircle)
3871                 m_style->setDashboardRegion(StyleDashboardRegion::Circle, region->m_label, top, right, bottom, left, region == first ? false : true);
3872             else if (region->m_isRectangle)
3873                 m_style->setDashboardRegion(StyleDashboardRegion::Rectangle, region->m_label, top, right, bottom, left, region == first ? false : true);
3874             region = region->m_next.get();
3875         }
3876
3877         m_element->document()->setHasDashboardRegions(true);
3878
3879         return;
3880     }
3881 #endif
3882     case CSSPropertyWebkitTextStrokeWidth: {
3883         HANDLE_INHERIT_AND_INITIAL(textStrokeWidth, TextStrokeWidth)
3884         float width = 0;
3885         switch (primitiveValue->getIdent()) {
3886         case CSSValueThin:
3887         case CSSValueMedium:
3888         case CSSValueThick: {
3889             double result = 1.0 / 48;
3890             if (primitiveValue->getIdent() == CSSValueMedium)
3891                 result *= 3;
3892             else if (primitiveValue->getIdent() == CSSValueThick)
3893                 result *= 5;
3894             width = CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS)->computeLength<float>(style(), m_rootElementStyle, zoomFactor);
3895             break;
3896         }
3897         default:
3898             width = primitiveValue->computeLength<float>(style(), m_rootElementStyle, zoomFactor);
3899             break;
3900         }
3901         m_style->setTextStrokeWidth(width);
3902         return;
3903     }
3904     case CSSPropertyWebkitTransform: {
3905         HANDLE_INHERIT_AND_INITIAL(transform, Transform);
3906         TransformOperations operations;
3907         createTransformOperations(value, style(), m_rootElementStyle, operations);
3908         m_style->setTransform(operations);
3909         return;
3910     }
3911     case CSSPropertyWebkitPerspective: {
3912         HANDLE_INHERIT_AND_INITIAL(perspective, Perspective)
3913
3914         if (!primitiveValue)
3915             return;
3916
3917         if (primitiveValue->getIdent() == CSSValueNone) {
3918             m_style->setPerspective(0);