CSS: Add a property cascading pass to style application.
[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, 2013 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 "CSSDefaultStyleSheets.h"
37 #include "CSSFilterImageValue.h"
38 #include "CSSFontFaceRule.h"
39 #include "CSSFontFeatureValue.h"
40 #include "CSSFontSelector.h"
41 #include "CSSFontValue.h"
42 #include "CSSGridTemplateValue.h"
43 #include "CSSLineBoxContainValue.h"
44 #include "CSSPageRule.h"
45 #include "CSSParser.h"
46 #include "CSSPrimitiveValueMappings.h"
47 #include "CSSPropertyNames.h"
48 #include "CSSReflectValue.h"
49 #include "CSSSelector.h"
50 #include "CSSSelectorList.h"
51 #include "CSSShadowValue.h"
52 #include "CSSStyleRule.h"
53 #include "CSSSupportsRule.h"
54 #include "CSSTimingFunctionValue.h"
55 #include "CSSValueList.h"
56 #include "CachedImage.h"
57 #include "CalculationValue.h"
58 #include "ContentData.h"
59 #include "Counter.h"
60 #include "CounterContent.h"
61 #include "CursorList.h"
62 #include "DeprecatedStyleBuilder.h"
63 #include "DocumentStyleSheetCollection.h"
64 #include "ElementRuleCollector.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 "HTMLOptGroupElement.h"
73 #include "HTMLOptionElement.h"
74 #include "HTMLProgressElement.h"
75 #include "HTMLStyleElement.h"
76 #include "HTMLTableElement.h"
77 #include "HTMLTextAreaElement.h"
78 #include "InsertionPoint.h"
79 #include "InspectorInstrumentation.h"
80 #include "KeyframeList.h"
81 #include "LinkHash.h"
82 #include "LocaleToScriptMapping.h"
83 #include "MathMLNames.h"
84 #include "MediaList.h"
85 #include "MediaQueryEvaluator.h"
86 #include "NodeRenderStyle.h"
87 #include "NodeRenderingTraversal.h"
88 #include "Page.h"
89 #include "PageRuleCollector.h"
90 #include "Pair.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 "RenderView.h"
99 #include "RuleSet.h"
100 #include "SVGDocumentExtensions.h"
101 #include "SVGFontFaceElement.h"
102 #include "SecurityOrigin.h"
103 #include "SelectorCheckerFastPath.h"
104 #include "Settings.h"
105 #include "ShadowData.h"
106 #include "ShadowRoot.h"
107 #include "StyleCachedImage.h"
108 #include "StyleFontSizeFunctions.h"
109 #include "StyleGeneratedImage.h"
110 #include "StylePendingImage.h"
111 #include "StyleProperties.h"
112 #include "StylePropertyShorthand.h"
113 #include "StyleRule.h"
114 #include "StyleRuleImport.h"
115 #include "StyleSheetContents.h"
116 #include "StyleSheetList.h"
117 #include "Text.h"
118 #include "TransformFunctions.h"
119 #include "TransformOperations.h"
120 #include "UserAgentStyleSheets.h"
121 #include "ViewportStyleResolver.h"
122 #include "VisitedLinkState.h"
123 #include "WebKitCSSKeyframeRule.h"
124 #include "WebKitCSSKeyframesRule.h"
125 #include "WebKitCSSRegionRule.h"
126 #include "WebKitCSSTransformValue.h"
127 #include "WebKitFontFamilyNames.h"
128 #include "XMLNames.h"
129 #include <wtf/StdLibExtras.h>
130 #include <wtf/Vector.h>
131
132 #if ENABLE(CSS_FILTERS)
133 #include "FilterOperation.h"
134 #include "WebKitCSSFilterValue.h"
135 #endif
136
137 #if ENABLE(CSS_IMAGE_SET)
138 #include "CSSImageSetValue.h"
139 #include "StyleCachedImageSet.h"
140 #endif
141
142 #if ENABLE(CSS_SHADERS)
143 #include "CustomFilterArrayParameter.h"
144 #include "CustomFilterColorParameter.h"
145 #include "CustomFilterConstants.h"
146 #include "CustomFilterNumberParameter.h"
147 #include "CustomFilterOperation.h"
148 #include "CustomFilterParameter.h"
149 #include "CustomFilterProgramInfo.h"
150 #include "CustomFilterTransformParameter.h"
151 #include "StyleCachedShader.h"
152 #include "StyleCustomFilterProgram.h"
153 #include "StyleCustomFilterProgramCache.h"
154 #include "StylePendingShader.h"
155 #include "StyleShader.h"
156 #include "WebKitCSSMixFunctionValue.h"
157 #include "WebKitCSSShaderValue.h"
158 #endif
159
160 #if ENABLE(CSS_SHAPES)
161 #include "CachedResourceLoader.h"
162 #endif
163
164 #if ENABLE(DASHBOARD_SUPPORT)
165 #include "DashboardRegion.h"
166 #endif
167
168 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
169 #include "HTMLAudioElement.h"
170 #endif
171
172 #if ENABLE(SVG)
173 #include "CachedSVGDocument.h"
174 #include "CachedSVGDocumentReference.h"
175 #include "SVGDocument.h"
176 #include "SVGElement.h"
177 #include "SVGNames.h"
178 #include "SVGURIReference.h"
179 #include "WebKitCSSSVGDocumentValue.h"
180 #endif
181
182 #if ENABLE(VIDEO_TRACK)
183 #include "WebVTTElement.h"
184 #endif
185
186 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
187 #include "HTMLMediaElement.h"
188 #endif
189
190 namespace WebCore {
191
192 using namespace HTMLNames;
193
194 class StyleResolver::CascadedProperties {
195 public:
196     CascadedProperties(TextDirection, WritingMode);
197
198     struct Property {
199         Property();
200         void apply(StyleResolver&);
201
202         CSSPropertyID id;
203         bool isPresent;
204         CSSValue* cssValue[3];
205     };
206
207     Property& property(CSSPropertyID);
208     void addMatches(const MatchResult&, bool important, int startIndex, int endIndex, bool inheritedOnly);
209
210     void set(CSSPropertyID, CSSValue&, unsigned linkMatchType);
211     void setDeferred(CSSPropertyID, CSSValue&, unsigned linkMatchType);
212
213     void applyDeferredProperties(StyleResolver&);
214
215 private:
216     void addStyleProperties(const StyleProperties&, StyleRule&, bool isImportant, bool inheritedOnly, PropertyWhitelistType, unsigned linkMatchType);
217     static void setPropertyInternal(Property&, CSSPropertyID, CSSValue&, unsigned linkMatchType);
218
219     Property m_properties[numCSSProperties + 1];
220     Vector<Property> m_deferredProperties;
221
222     TextDirection m_direction;
223     WritingMode m_writingMode;
224 };
225
226 #define HANDLE_INHERIT(prop, Prop) \
227 if (isInherit) { \
228     m_state.style()->set##Prop(m_state.parentStyle()->prop()); \
229     return; \
230 }
231
232 #define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
233 HANDLE_INHERIT(prop, Prop) \
234 if (isInitial) { \
235     m_state.style()->set##Prop(RenderStyle::initial##Prop()); \
236     return; \
237 }
238
239 RenderStyle* StyleResolver::s_styleNotYetAvailable;
240
241 inline void StyleResolver::State::cacheBorderAndBackground()
242 {
243     m_hasUAAppearance = m_style->hasAppearance();
244     if (m_hasUAAppearance) {
245         m_borderData = m_style->border();
246         m_backgroundData = *m_style->backgroundLayers();
247         m_backgroundColor = m_style->backgroundColor();
248     }
249 }
250
251 inline void StyleResolver::State::clear()
252 {
253     m_element = nullptr;
254     m_styledElement = nullptr;
255     m_parentStyle = nullptr;
256     m_parentNode = nullptr;
257     m_regionForStyling = nullptr;
258     m_pendingImageProperties.clear();
259 #if ENABLE(CSS_SHADERS)
260     m_hasPendingShaders = false;
261 #endif
262 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
263     m_pendingSVGDocuments.clear();
264 #endif
265 }
266
267 void StyleResolver::MatchResult::addMatchedProperties(const StyleProperties& properties, StyleRule* rule, unsigned linkMatchType, PropertyWhitelistType propertyWhitelistType)
268 {
269     matchedProperties.grow(matchedProperties.size() + 1);
270     StyleResolver::MatchedProperties& newProperties = matchedProperties.last();
271     newProperties.properties = const_cast<StyleProperties*>(&properties);
272     newProperties.linkMatchType = linkMatchType;
273     newProperties.whitelistType = propertyWhitelistType;
274     matchedRules.append(rule);
275 }
276
277 StyleResolver::StyleResolver(Document& document, bool matchAuthorAndUserStyles)
278     : m_matchedPropertiesCacheAdditionsSinceLastSweep(0)
279     , m_matchedPropertiesCacheSweepTimer(this, &StyleResolver::sweepMatchedPropertiesCache)
280     , m_document(document)
281     , m_matchAuthorAndUserStyles(matchAuthorAndUserStyles)
282     , m_fontSelector(CSSFontSelector::create(&m_document))
283 #if ENABLE(CSS_DEVICE_ADAPTATION)
284     , m_viewportStyleResolver(ViewportStyleResolver::create(&document))
285 #endif
286     , m_deprecatedStyleBuilder(DeprecatedStyleBuilder::sharedStyleBuilder())
287     , m_styleMap(this)
288 {
289     Element* root = m_document.documentElement();
290
291     CSSDefaultStyleSheets::initDefaultStyle(root);
292
293     // construct document root element default style. this is needed
294     // to evaluate media queries that contain relative constraints, like "screen and (max-width: 10em)"
295     // This is here instead of constructor, because when constructor is run,
296     // document doesn't have documentElement
297     // NOTE: this assumes that element that gets passed to styleForElement -call
298     // is always from the document that owns the style selector
299     FrameView* view = m_document.view();
300     if (view)
301         m_medium = adoptPtr(new MediaQueryEvaluator(view->mediaType()));
302     else
303         m_medium = adoptPtr(new MediaQueryEvaluator("all"));
304
305     if (root)
306         m_rootDefaultStyle = styleForElement(root, 0, DisallowStyleSharing, MatchOnlyUserAgentRules);
307
308     if (m_rootDefaultStyle && view)
309         m_medium = adoptPtr(new MediaQueryEvaluator(view->mediaType(), &view->frame(), m_rootDefaultStyle.get()));
310
311     m_ruleSets.resetAuthorStyle();
312
313     DocumentStyleSheetCollection& styleSheetCollection = m_document.styleSheetCollection();
314     m_ruleSets.initUserStyle(styleSheetCollection, *m_medium, *this);
315
316 #if ENABLE(SVG_FONTS)
317     if (m_document.svgExtensions()) {
318         const HashSet<SVGFontFaceElement*>& svgFontFaceElements = m_document.svgExtensions()->svgFontFaceElements();
319         HashSet<SVGFontFaceElement*>::const_iterator end = svgFontFaceElements.end();
320         for (HashSet<SVGFontFaceElement*>::const_iterator it = svgFontFaceElements.begin(); it != end; ++it)
321             fontSelector()->addFontFaceRule((*it)->fontFaceRule());
322     }
323 #endif
324
325     appendAuthorStyleSheets(0, styleSheetCollection.activeAuthorStyleSheets());
326 }
327
328 void StyleResolver::appendAuthorStyleSheets(unsigned firstNew, const Vector<RefPtr<CSSStyleSheet>>& styleSheets)
329 {
330     m_ruleSets.appendAuthorStyleSheets(firstNew, styleSheets, m_medium.get(), m_inspectorCSSOMWrappers, document().isViewSource(), this);
331     if (auto renderView = document().renderView())
332         renderView->style().font().update(fontSelector());
333
334 #if ENABLE(CSS_DEVICE_ADAPTATION)
335     viewportStyleResolver()->resolve();
336 #endif
337 }
338
339 void StyleResolver::pushParentElement(Element* parent)
340 {
341     const ContainerNode* parentsParent = parent->parentOrShadowHostElement();
342
343     // We are not always invoked consistently. For example, script execution can cause us to enter
344     // style recalc in the middle of tree building. We may also be invoked from somewhere within the tree.
345     // Reset the stack in this case, or if we see a new root element.
346     // Otherwise just push the new parent.
347     if (!parentsParent || m_selectorFilter.parentStackIsEmpty())
348         m_selectorFilter.setupParentStack(parent);
349     else
350         m_selectorFilter.pushParent(parent);
351
352     // Note: We mustn't skip ShadowRoot nodes for the scope stack.
353     if (m_scopeResolver)
354         m_scopeResolver->push(parent, parent->parentOrShadowHostNode());
355 }
356
357 void StyleResolver::popParentElement(Element* parent)
358 {
359     // Note that we may get invoked for some random elements in some wacky cases during style resolve.
360     // Pause maintaining the stack in this case.
361     if (m_selectorFilter.parentStackIsConsistent(parent))
362         m_selectorFilter.popParent();
363     if (m_scopeResolver)
364         m_scopeResolver->pop(parent);
365 }
366
367 void StyleResolver::pushParentShadowRoot(const ShadowRoot* shadowRoot)
368 {
369     ASSERT(shadowRoot->hostElement());
370     if (m_scopeResolver)
371         m_scopeResolver->push(shadowRoot, shadowRoot->hostElement());
372 }
373
374 void StyleResolver::popParentShadowRoot(const ShadowRoot* shadowRoot)
375 {
376     ASSERT(shadowRoot->hostElement());
377     if (m_scopeResolver)
378         m_scopeResolver->pop(shadowRoot);
379 }
380
381 // This is a simplified style setting function for keyframe styles
382 void StyleResolver::addKeyframeStyle(PassRefPtr<StyleRuleKeyframes> rule)
383 {
384     AtomicString s(rule->name());
385     m_keyframesRuleMap.set(s.impl(), rule);
386 }
387
388 StyleResolver::~StyleResolver()
389 {
390     m_fontSelector->clearDocument();
391
392 #if ENABLE(CSS_DEVICE_ADAPTATION)
393     m_viewportStyleResolver->clearDocument();
394 #endif
395 }
396
397 void StyleResolver::sweepMatchedPropertiesCache(Timer<StyleResolver>*)
398 {
399     // Look for cache entries containing a style declaration with a single ref and remove them.
400     // This may happen when an element attribute mutation causes it to generate a new inlineStyle()
401     // or presentationAttributeStyle(), potentially leaving this cache with the last ref on the old one.
402     Vector<unsigned, 16> toRemove;
403     MatchedPropertiesCache::iterator it = m_matchedPropertiesCache.begin();
404     MatchedPropertiesCache::iterator end = m_matchedPropertiesCache.end();
405     for (; it != end; ++it) {
406         Vector<MatchedProperties>& matchedProperties = it->value.matchedProperties;
407         for (size_t i = 0; i < matchedProperties.size(); ++i) {
408             if (matchedProperties[i].properties->hasOneRef()) {
409                 toRemove.append(it->key);
410                 break;
411             }
412         }
413     }
414     for (size_t i = 0; i < toRemove.size(); ++i)
415         m_matchedPropertiesCache.remove(toRemove[i]);
416
417     m_matchedPropertiesCacheAdditionsSinceLastSweep = 0;
418 }
419
420 inline bool StyleResolver::styleSharingCandidateMatchesHostRules()
421 {
422 #if ENABLE(SHADOW_DOM)
423     return m_scopeResolver && m_scopeResolver->styleSharingCandidateMatchesHostRules(m_state.element());
424 #else
425     return false;
426 #endif
427 }
428
429 bool StyleResolver::classNamesAffectedByRules(const SpaceSplitString& classNames) const
430 {
431     for (unsigned i = 0; i < classNames.size(); ++i) {
432         if (m_ruleSets.features().classesInRules.contains(classNames[i].impl()))
433             return true;
434     }
435     return false;
436 }
437
438 inline void StyleResolver::State::initElement(Element* e)
439 {
440     m_element = e;
441     m_styledElement = e && e->isStyledElement() ? toStyledElement(e) : nullptr;
442     m_elementLinkState = e ? e->document().visitedLinkState().determineLinkState(e) : NotInsideLink;
443 }
444
445 inline void StyleResolver::initElement(Element* e)
446 {
447     if (m_state.element() != e) {
448         m_state.initElement(e);
449         if (e && e == e->document().documentElement()) {
450             e->document().setDirectionSetOnDocumentElement(false);
451             e->document().setWritingModeSetOnDocumentElement(false);
452         }
453     }
454 }
455
456 inline void StyleResolver::State::initForStyleResolve(Document& document, Element* e, RenderStyle* parentStyle, RenderRegion* regionForStyling)
457 {
458     m_regionForStyling = regionForStyling;
459
460     if (e) {
461         m_parentNode = NodeRenderingTraversal::parent(e);
462         bool resetStyleInheritance = hasShadowRootParent(*e) && toShadowRoot(e->parentNode())->resetStyleInheritance();
463         m_parentStyle = resetStyleInheritance ? 0 :
464             parentStyle ? parentStyle :
465             m_parentNode ? m_parentNode->renderStyle() : 0;
466     } else {
467         m_parentNode = 0;
468         m_parentStyle = parentStyle;
469     }
470
471     Node* docElement = e ? e->document().documentElement() : 0;
472     RenderStyle* docStyle = document.renderStyle();
473     m_rootElementStyle = docElement && e != docElement ? docElement->renderStyle() : docStyle;
474
475     m_style = 0;
476     m_pendingImageProperties.clear();
477     m_fontDirty = false;
478 }
479
480 static const unsigned cStyleSearchThreshold = 10;
481 static const unsigned cStyleSearchLevelThreshold = 10;
482
483 static inline bool parentElementPreventsSharing(const Element* parentElement)
484 {
485     if (!parentElement)
486         return false;
487     return parentElement->hasFlagsSetDuringStylingOfChildren();
488 }
489
490 Node* StyleResolver::locateCousinList(Element* parent, unsigned& visitedNodeCount) const
491 {
492     if (visitedNodeCount >= cStyleSearchThreshold * cStyleSearchLevelThreshold)
493         return 0;
494     if (!parent || !parent->isStyledElement())
495         return 0;
496     StyledElement* p = toStyledElement(parent);
497     if (p->inlineStyle())
498         return 0;
499 #if ENABLE(SVG)
500     if (p->isSVGElement() && toSVGElement(p)->animatedSMILStyleProperties())
501         return 0;
502 #endif
503     if (p->hasID() && m_ruleSets.features().idsInRules.contains(p->idForStyleResolution().impl()))
504         return 0;
505
506     RenderStyle* parentStyle = p->renderStyle();
507     unsigned subcount = 0;
508     Node* thisCousin = p;
509     Node* currentNode = p->previousSibling();
510
511     // Reserve the tries for this level. This effectively makes sure that the algorithm
512     // will never go deeper than cStyleSearchLevelThreshold levels into recursion.
513     visitedNodeCount += cStyleSearchThreshold;
514     while (thisCousin) {
515         while (currentNode) {
516             ++subcount;
517             if (currentNode->renderStyle() == parentStyle && currentNode->lastChild()
518                 && currentNode->isElementNode() && !parentElementPreventsSharing(toElement(currentNode))
519 #if ENABLE(SHADOW_DOM)
520                 && !toElement(currentNode)->authorShadowRoot()
521 #endif
522                 ) {
523                 // Adjust for unused reserved tries.
524                 visitedNodeCount -= cStyleSearchThreshold - subcount;
525                 return currentNode->lastChild();
526             }
527             if (subcount >= cStyleSearchThreshold)
528                 return 0;
529             currentNode = currentNode->previousSibling();
530         }
531         currentNode = locateCousinList(thisCousin->parentElement(), visitedNodeCount);
532         thisCousin = currentNode;
533     }
534
535     return 0;
536 }
537
538 bool StyleResolver::styleSharingCandidateMatchesRuleSet(RuleSet* ruleSet)
539 {
540     if (!ruleSet)
541         return false;
542
543     ElementRuleCollector collector(this, m_state);
544     return collector.hasAnyMatchingRules(ruleSet);
545 }
546
547 bool StyleResolver::canShareStyleWithControl(StyledElement* element) const
548 {
549     const State& state = m_state;
550     HTMLInputElement* thisInputElement = element->toInputElement();
551     HTMLInputElement* otherInputElement = state.element()->toInputElement();
552
553     if (!thisInputElement || !otherInputElement)
554         return false;
555
556     if (thisInputElement->elementData() != otherInputElement->elementData()) {
557         if (thisInputElement->fastGetAttribute(typeAttr) != otherInputElement->fastGetAttribute(typeAttr))
558             return false;
559         if (thisInputElement->fastGetAttribute(readonlyAttr) != otherInputElement->fastGetAttribute(readonlyAttr))
560             return false;
561     }
562
563     if (thisInputElement->isAutofilled() != otherInputElement->isAutofilled())
564         return false;
565     if (thisInputElement->shouldAppearChecked() != otherInputElement->shouldAppearChecked())
566         return false;
567     if (thisInputElement->shouldAppearIndeterminate() != otherInputElement->shouldAppearIndeterminate())
568         return false;
569     if (thisInputElement->isRequired() != otherInputElement->isRequired())
570         return false;
571
572     if (element->isDisabledFormControl() != state.element()->isDisabledFormControl())
573         return false;
574
575     if (element->isDefaultButtonForForm() != state.element()->isDefaultButtonForForm())
576         return false;
577
578     if (state.document().containsValidityStyleRules()) {
579         bool willValidate = element->willValidate();
580
581         if (willValidate != state.element()->willValidate())
582             return false;
583
584         if (willValidate && (element->isValidFormControlElement() != state.element()->isValidFormControlElement()))
585             return false;
586
587         if (element->isInRange() != state.element()->isInRange())
588             return false;
589
590         if (element->isOutOfRange() != state.element()->isOutOfRange())
591             return false;
592     }
593
594     return true;
595 }
596
597 static inline bool elementHasDirectionAuto(Element* element)
598 {
599     // FIXME: This line is surprisingly hot, we may wish to inline hasDirectionAuto into StyleResolver.
600     return element->isHTMLElement() && toHTMLElement(element)->hasDirectionAuto();
601 }
602
603 bool StyleResolver::sharingCandidateHasIdenticalStyleAffectingAttributes(StyledElement* sharingCandidate) const
604 {
605     const State& state = m_state;
606     if (state.element()->elementData() == sharingCandidate->elementData())
607         return true;
608     if (state.element()->fastGetAttribute(XMLNames::langAttr) != sharingCandidate->fastGetAttribute(XMLNames::langAttr))
609         return false;
610     if (state.element()->fastGetAttribute(langAttr) != sharingCandidate->fastGetAttribute(langAttr))
611         return false;
612
613     if (!state.elementAffectedByClassRules()) {
614         if (sharingCandidate->hasClass() && classNamesAffectedByRules(sharingCandidate->classNames()))
615             return false;
616     } else if (sharingCandidate->hasClass()) {
617 #if ENABLE(SVG)
618         // SVG elements require a (slow!) getAttribute comparision because "class" is an animatable attribute for SVG.
619         if (state.element()->isSVGElement()) {
620             if (state.element()->getAttribute(classAttr) != sharingCandidate->getAttribute(classAttr))
621                 return false;
622         } else {
623 #endif
624             if (state.element()->classNames() != sharingCandidate->classNames())
625                 return false;
626 #if ENABLE(SVG)
627         }
628 #endif
629     } else
630         return false;
631
632     if (state.styledElement()->presentationAttributeStyle() != sharingCandidate->presentationAttributeStyle())
633         return false;
634
635 #if ENABLE(PROGRESS_ELEMENT)
636     if (state.element()->hasTagName(progressTag)) {
637         if (state.element()->shouldAppearIndeterminate() != sharingCandidate->shouldAppearIndeterminate())
638             return false;
639     }
640 #endif
641
642     return true;
643 }
644
645 bool StyleResolver::canShareStyleWithElement(StyledElement* element) const
646 {
647     RenderStyle* style = element->renderStyle();
648     const State& state = m_state;
649
650     if (!style)
651         return false;
652     if (style->unique())
653         return false;
654     if (style->hasUniquePseudoStyle())
655         return false;
656     if (element->tagQName() != state.element()->tagQName())
657         return false;
658     if (element->inlineStyle())
659         return false;
660     if (element->needsStyleRecalc())
661         return false;
662 #if ENABLE(SVG)
663     if (element->isSVGElement() && toSVGElement(element)->animatedSMILStyleProperties())
664         return false;
665 #endif
666     if (element->isLink() != state.element()->isLink())
667         return false;
668     if (element->hovered() != state.element()->hovered())
669         return false;
670     if (element->active() != state.element()->active())
671         return false;
672     if (element->focused() != state.element()->focused())
673         return false;
674     if (element->shadowPseudoId() != state.element()->shadowPseudoId())
675         return false;
676     if (element == element->document().cssTarget())
677         return false;
678     if (!sharingCandidateHasIdenticalStyleAffectingAttributes(element))
679         return false;
680     if (element->additionalPresentationAttributeStyle() != state.styledElement()->additionalPresentationAttributeStyle())
681         return false;
682
683     if (element->hasID() && m_ruleSets.features().idsInRules.contains(element->idForStyleResolution().impl()))
684         return false;
685
686     // FIXME: We should share style for option and optgroup whenever possible.
687     // Before doing so, we need to resolve issues in HTMLSelectElement::recalcListItems
688     // and RenderMenuList::setText. See also https://bugs.webkit.org/show_bug.cgi?id=88405
689     if (isHTMLOptionElement(element) || isHTMLOptGroupElement(element))
690         return false;
691
692     bool isControl = element->isFormControlElement();
693
694     if (isControl != state.element()->isFormControlElement())
695         return false;
696
697     if (isControl && !canShareStyleWithControl(element))
698         return false;
699
700     if (style->transitions() || style->animations())
701         return false;
702
703 #if USE(ACCELERATED_COMPOSITING)
704     // Turn off style sharing for elements that can gain layers for reasons outside of the style system.
705     // See comments in RenderObject::setStyle().
706     if (element->hasTagName(iframeTag) || element->hasTagName(frameTag) || element->hasTagName(embedTag) || element->hasTagName(objectTag) || element->hasTagName(appletTag) || element->hasTagName(canvasTag))
707         return false;
708
709 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
710     // With proxying, the media elements are backed by a RenderEmbeddedObject.
711     if ((element->hasTagName(videoTag) || element->hasTagName(audioTag)) && toMediaElement(element)->shouldUseVideoPluginProxy())
712         return false;
713 #endif
714
715 #endif
716
717     if (elementHasDirectionAuto(element))
718         return false;
719
720     if (element->isLink() && state.elementLinkState() != style->insideLink())
721         return false;
722
723 #if ENABLE(VIDEO_TRACK)
724     // Deny sharing styles between WebVTT and non-WebVTT nodes.
725     if (element->isWebVTTElement() != state.element()->isWebVTTElement())
726         return false;
727
728     if (element->isWebVTTElement() && state.element()->isWebVTTElement() && toWebVTTElement(element)->isPastNode() != toWebVTTElement(state.element())->isPastNode())
729         return false;
730 #endif
731
732 #if ENABLE(FULLSCREEN_API)
733     if (element == element->document().webkitCurrentFullScreenElement() || state.element() == state.document().webkitCurrentFullScreenElement())
734         return false;
735 #endif
736     return true;
737 }
738
739 inline StyledElement* StyleResolver::findSiblingForStyleSharing(Node* node, unsigned& count) const
740 {
741     for (; node; node = node->previousSibling()) {
742         if (!node->isStyledElement())
743             continue;
744         if (canShareStyleWithElement(toStyledElement(node)))
745             break;
746         if (count++ == cStyleSearchThreshold)
747             return 0;
748     }
749     return toStyledElement(node);
750 }
751
752 RenderStyle* StyleResolver::locateSharedStyle()
753 {
754     State& state = m_state;
755     if (!state.styledElement() || !state.parentStyle())
756         return 0;
757
758     // If the element has inline style it is probably unique.
759     if (state.styledElement()->inlineStyle())
760         return 0;
761 #if ENABLE(SVG)
762     if (state.styledElement()->isSVGElement() && toSVGElement(state.styledElement())->animatedSMILStyleProperties())
763         return 0;
764 #endif
765     // Ids stop style sharing if they show up in the stylesheets.
766     if (state.styledElement()->hasID() && m_ruleSets.features().idsInRules.contains(state.styledElement()->idForStyleResolution().impl()))
767         return 0;
768     if (parentElementPreventsSharing(state.element()->parentElement()))
769         return 0;
770     if (state.element() == state.document().cssTarget())
771         return 0;
772     if (elementHasDirectionAuto(state.element()))
773         return 0;
774
775     // Cache whether state.element is affected by any known class selectors.
776     // FIXME: This shouldn't be a member variable. The style sharing code could be factored out of StyleResolver.
777     state.setElementAffectedByClassRules(state.element() && state.element()->hasClass() && classNamesAffectedByRules(state.element()->classNames()));
778
779     // Check previous siblings and their cousins.
780     unsigned count = 0;
781     unsigned visitedNodeCount = 0;
782     StyledElement* shareElement = 0;
783     Node* cousinList = state.styledElement()->previousSibling();
784     while (cousinList) {
785         shareElement = findSiblingForStyleSharing(cousinList, count);
786         if (shareElement)
787             break;
788         cousinList = locateCousinList(cousinList->parentElement(), visitedNodeCount);
789     }
790
791     // If we have exhausted all our budget or our cousins.
792     if (!shareElement)
793         return 0;
794
795     // Can't share if sibling rules apply. This is checked at the end as it should rarely fail.
796     if (styleSharingCandidateMatchesRuleSet(m_ruleSets.sibling()))
797         return 0;
798     // Can't share if attribute rules apply.
799     if (styleSharingCandidateMatchesRuleSet(m_ruleSets.uncommonAttribute()))
800         return 0;
801     // Can't share if @host @-rules apply.
802     if (styleSharingCandidateMatchesHostRules())
803         return 0;
804     // Tracking child index requires unique style for each node. This may get set by the sibling rule match above.
805     if (parentElementPreventsSharing(state.element()->parentElement()))
806         return 0;
807     return shareElement->renderStyle();
808 }
809
810 static inline bool isAtShadowBoundary(const Element* element)
811 {
812     if (!element)
813         return false;
814     ContainerNode* parentNode = element->parentNode();
815     return parentNode && parentNode->isShadowRoot();
816 }
817
818 PassRef<RenderStyle> StyleResolver::styleForElement(Element* element, RenderStyle* defaultParent,
819     StyleSharingBehavior sharingBehavior, RuleMatchingBehavior matchingBehavior, RenderRegion* regionForStyling)
820 {
821     // Once an element has a renderer, we don't try to destroy it, since otherwise the renderer
822     // will vanish if a style recalc happens during loading.
823     if (sharingBehavior == AllowStyleSharing && !element->document().haveStylesheetsLoaded() && !element->renderer()) {
824         if (!s_styleNotYetAvailable) {
825             s_styleNotYetAvailable = &RenderStyle::create().leakRef();
826             s_styleNotYetAvailable->setDisplay(NONE);
827             s_styleNotYetAvailable->font().update(m_fontSelector);
828         }
829         element->document().setHasNodesWithPlaceholderStyle();
830         return *s_styleNotYetAvailable;
831     }
832
833     State& state = m_state;
834     initElement(element);
835     state.initForStyleResolve(document(), element, defaultParent, regionForStyling);
836     if (sharingBehavior == AllowStyleSharing) {
837         if (RenderStyle* sharedStyle = locateSharedStyle()) {
838             state.clear();
839             return *sharedStyle;
840         }
841     }
842
843     if (state.parentStyle()) {
844         state.setStyle(RenderStyle::create());
845         state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
846     } else {
847         state.setStyle(defaultStyleForElement());
848         state.setParentStyle(RenderStyle::clone(state.style()));
849     }
850
851     if (element->isLink()) {
852         state.style()->setIsLink(true);
853         EInsideLink linkState = state.elementLinkState();
854         if (linkState != NotInsideLink) {
855             bool forceVisited = InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoVisited);
856             if (forceVisited)
857                 linkState = InsideVisitedLink;
858         }
859         state.style()->setInsideLink(linkState);
860     }
861
862     bool needsCollection = false;
863     CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(element, needsCollection);
864     if (needsCollection)
865         m_ruleSets.collectFeatures(document().isViewSource(), m_scopeResolver.get());
866
867     ElementRuleCollector collector(this, state);
868     collector.setRegionForStyling(regionForStyling);
869     collector.setMedium(m_medium.get());
870
871     if (matchingBehavior == MatchOnlyUserAgentRules)
872         collector.matchUARules();
873     else
874         collector.matchAllRules(m_matchAuthorAndUserStyles, matchingBehavior != MatchAllRulesExcludingSMIL);
875
876     applyMatchedProperties(collector.matchedResult(), element);
877
878     // Clean up our style object's display and text decorations (among other fixups).
879     adjustRenderStyle(*state.style(), *state.parentStyle(), element);
880
881     state.clear(); // Clear out for the next resolve.
882
883     document().didAccessStyleResolver();
884
885     // Now return the style.
886     return state.takeStyle();
887 }
888
889 PassRef<RenderStyle> StyleResolver::styleForKeyframe(const RenderStyle* elementStyle, const StyleKeyframe* keyframe, KeyframeValue& keyframeValue)
890 {
891     MatchResult result;
892     result.addMatchedProperties(keyframe->properties());
893
894     ASSERT(!m_state.style());
895
896     State& state = m_state;
897
898     // Create the style
899     state.setStyle(RenderStyle::clone(elementStyle));
900     state.setLineHeightValue(0);
901
902     // We don't need to bother with !important. Since there is only ever one
903     // decl, there's nothing to override. So just add the first properties.
904     bool inheritedOnly = false;
905     applyMatchedProperties<HighPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
906
907     // If our font got dirtied, go ahead and update it now.
908     updateFont();
909
910     // Line-height is set when we are sure we decided on the font-size
911     if (state.lineHeightValue())
912         applyProperty(CSSPropertyLineHeight, state.lineHeightValue());
913
914     // Now do rest of the properties.
915     applyMatchedProperties<LowPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
916
917     // If our font got dirtied by one of the non-essential font props,
918     // go ahead and update it a second time.
919     updateFont();
920
921     // Start loading resources referenced by this style.
922     loadPendingResources();
923     
924     // Add all the animating properties to the keyframe.
925     unsigned propertyCount = keyframe->properties().propertyCount();
926     for (unsigned i = 0; i < propertyCount; ++i) {
927         CSSPropertyID property = keyframe->properties().propertyAt(i).id();
928         // Timing-function within keyframes is special, because it is not animated; it just
929         // describes the timing function between this keyframe and the next.
930         if (property != CSSPropertyWebkitAnimationTimingFunction)
931             keyframeValue.addProperty(property);
932     }
933
934     document().didAccessStyleResolver();
935
936     return state.takeStyle();
937 }
938
939 void StyleResolver::keyframeStylesForAnimation(Element* e, const RenderStyle* elementStyle, KeyframeList& list)
940 {
941     list.clear();
942
943     // Get the keyframesRule for this name
944     if (!e || list.animationName().isEmpty())
945         return;
946
947     m_keyframesRuleMap.checkConsistency();
948
949     KeyframesRuleMap::iterator it = m_keyframesRuleMap.find(list.animationName().impl());
950     if (it == m_keyframesRuleMap.end())
951         return;
952
953     const StyleRuleKeyframes* keyframesRule = it->value.get();
954
955     // Construct and populate the style for each keyframe
956     const Vector<RefPtr<StyleKeyframe>>& keyframes = keyframesRule->keyframes();
957     for (unsigned i = 0; i < keyframes.size(); ++i) {
958         // Apply the declaration to the style. This is a simplified version of the logic in styleForElement
959         initElement(e);
960         m_state.initForStyleResolve(document(), e);
961
962         const StyleKeyframe* keyframe = keyframes[i].get();
963
964         KeyframeValue keyframeValue(0, 0);
965         keyframeValue.setStyle(styleForKeyframe(elementStyle, keyframe, keyframeValue));
966
967         // Add this keyframe style to all the indicated key times
968         Vector<double> keys;
969         keyframe->getKeys(keys);
970         for (size_t keyIndex = 0; keyIndex < keys.size(); ++keyIndex) {
971             keyframeValue.setKey(keys[keyIndex]);
972             list.insert(keyframeValue);
973         }
974     }
975
976     // If the 0% keyframe is missing, create it (but only if there is at least one other keyframe)
977     int initialListSize = list.size();
978     if (initialListSize > 0 && list[0].key()) {
979         static StyleKeyframe* zeroPercentKeyframe;
980         if (!zeroPercentKeyframe) {
981             zeroPercentKeyframe = StyleKeyframe::create(MutableStyleProperties::create()).leakRef();
982             zeroPercentKeyframe->setKeyText("0%");
983         }
984         KeyframeValue keyframeValue(0, 0);
985         keyframeValue.setStyle(styleForKeyframe(elementStyle, zeroPercentKeyframe, keyframeValue));
986         list.insert(keyframeValue);
987     }
988
989     // If the 100% keyframe is missing, create it (but only if there is at least one other keyframe)
990     if (initialListSize > 0 && (list[list.size() - 1].key() != 1)) {
991         static StyleKeyframe* hundredPercentKeyframe;
992         if (!hundredPercentKeyframe) {
993             hundredPercentKeyframe = StyleKeyframe::create(MutableStyleProperties::create()).leakRef();
994             hundredPercentKeyframe->setKeyText("100%");
995         }
996         KeyframeValue keyframeValue(1, 0);
997         keyframeValue.setStyle(styleForKeyframe(elementStyle, hundredPercentKeyframe, keyframeValue));
998         list.insert(keyframeValue);
999     }
1000 }
1001
1002 PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(Element* e, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle)
1003 {
1004     ASSERT(parentStyle);
1005     if (!e)
1006         return 0;
1007
1008     State& state = m_state;
1009
1010     initElement(e);
1011
1012     state.initForStyleResolve(document(), e, parentStyle);
1013
1014     if (m_state.parentStyle()) {
1015         state.setStyle(RenderStyle::create());
1016         state.style()->inheritFrom(m_state.parentStyle());
1017     } else {
1018         state.setStyle(defaultStyleForElement());
1019         state.setParentStyle(RenderStyle::clone(state.style()));
1020     }
1021
1022     // Since we don't use pseudo-elements in any of our quirk/print user agent rules, don't waste time walking
1023     // those rules.
1024
1025     // Check UA, user and author rules.
1026     ElementRuleCollector collector(this, state);
1027     collector.setPseudoStyleRequest(pseudoStyleRequest);
1028     collector.setMedium(m_medium.get());
1029     collector.matchUARules();
1030
1031     if (m_matchAuthorAndUserStyles) {
1032         collector.matchUserRules(false);
1033         collector.matchAuthorRules(false);
1034     }
1035
1036     if (collector.matchedResult().matchedProperties.isEmpty())
1037         return 0;
1038
1039     state.style()->setStyleType(pseudoStyleRequest.pseudoId);
1040
1041     applyMatchedProperties(collector.matchedResult(), e);
1042
1043     // Clean up our style object's display and text decorations (among other fixups).
1044     adjustRenderStyle(*state.style(), *m_state.parentStyle(), 0);
1045
1046     // Start loading resources referenced by this style.
1047     loadPendingResources();
1048
1049     document().didAccessStyleResolver();
1050
1051     // Now return the style.
1052     return state.takeStyle();
1053 }
1054
1055 PassRef<RenderStyle> StyleResolver::styleForPage(int pageIndex)
1056 {
1057     m_state.initForStyleResolve(document(), document().documentElement()); // m_rootElementStyle will be set to the document style.
1058
1059     m_state.setStyle(RenderStyle::create());
1060     m_state.style()->inheritFrom(m_state.rootElementStyle());
1061
1062     PageRuleCollector collector(m_state, m_ruleSets);
1063     collector.matchAllPageRules(pageIndex);
1064     m_state.setLineHeightValue(0);
1065     bool inheritedOnly = false;
1066
1067     MatchResult& result = collector.matchedResult();
1068     applyMatchedProperties<HighPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
1069
1070     // If our font got dirtied, go ahead and update it now.
1071     updateFont();
1072
1073     // Line-height is set when we are sure we decided on the font-size.
1074     if (m_state.lineHeightValue())
1075         applyProperty(CSSPropertyLineHeight, m_state.lineHeightValue());
1076
1077     applyMatchedProperties<LowPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
1078
1079     // Start loading resources referenced by this style.
1080     loadPendingResources();
1081
1082     document().didAccessStyleResolver();
1083
1084     // Now return the style.
1085     return m_state.takeStyle();
1086 }
1087
1088 PassRef<RenderStyle> StyleResolver::defaultStyleForElement()
1089 {
1090     m_state.setStyle(RenderStyle::create());
1091     // Make sure our fonts are initialized if we don't inherit them from our parent style.
1092     if (Settings* settings = documentSettings()) {
1093         initializeFontStyle(settings);
1094         m_state.style()->font().update(fontSelector());
1095     } else
1096         m_state.style()->font().update(0);
1097
1098     return m_state.takeStyle();
1099 }
1100
1101 static void addIntrinsicMargins(RenderStyle& style)
1102 {
1103     // Intrinsic margin value.
1104     const int intrinsicMargin = 2 * style.effectiveZoom();
1105
1106     // FIXME: Using width/height alone and not also dealing with min-width/max-width is flawed.
1107     // FIXME: Using "quirk" to decide the margin wasn't set is kind of lame.
1108     if (style.width().isIntrinsicOrAuto()) {
1109         if (style.marginLeft().quirk())
1110             style.setMarginLeft(Length(intrinsicMargin, Fixed));
1111         if (style.marginRight().quirk())
1112             style.setMarginRight(Length(intrinsicMargin, Fixed));
1113     }
1114
1115     if (style.height().isAuto()) {
1116         if (style.marginTop().quirk())
1117             style.setMarginTop(Length(intrinsicMargin, Fixed));
1118         if (style.marginBottom().quirk())
1119             style.setMarginBottom(Length(intrinsicMargin, Fixed));
1120     }
1121 }
1122
1123 static EDisplay equivalentBlockDisplay(EDisplay display, bool isFloating, bool strictParsing)
1124 {
1125     switch (display) {
1126     case BLOCK:
1127     case TABLE:
1128     case BOX:
1129     case FLEX:
1130     case GRID:
1131         return display;
1132
1133     case LIST_ITEM:
1134         // It is a WinIE bug that floated list items lose their bullets, so we'll emulate the quirk, but only in quirks mode.
1135         if (!strictParsing && isFloating)
1136             return BLOCK;
1137         return display;
1138     case INLINE_TABLE:
1139         return TABLE;
1140     case INLINE_BOX:
1141         return BOX;
1142     case INLINE_FLEX:
1143         return FLEX;
1144     case INLINE_GRID:
1145         return GRID;
1146
1147     case INLINE:
1148     case RUN_IN:
1149     case COMPACT:
1150     case INLINE_BLOCK:
1151     case TABLE_ROW_GROUP:
1152     case TABLE_HEADER_GROUP:
1153     case TABLE_FOOTER_GROUP:
1154     case TABLE_ROW:
1155     case TABLE_COLUMN_GROUP:
1156     case TABLE_COLUMN:
1157     case TABLE_CELL:
1158     case TABLE_CAPTION:
1159         return BLOCK;
1160     case NONE:
1161         ASSERT_NOT_REACHED();
1162         return NONE;
1163     }
1164     ASSERT_NOT_REACHED();
1165     return BLOCK;
1166 }
1167
1168 // CSS requires text-decoration to be reset at each DOM element for tables, 
1169 // inline blocks, inline tables, run-ins, shadow DOM crossings, floating elements,
1170 // and absolute or relatively positioned elements.
1171 static bool doesNotInheritTextDecoration(const RenderStyle& style, Element* e)
1172 {
1173     return style.display() == TABLE || style.display() == INLINE_TABLE || style.display() == RUN_IN
1174         || style.display() == INLINE_BLOCK || style.display() == INLINE_BOX || isAtShadowBoundary(e)
1175         || style.isFloating() || style.hasOutOfFlowPosition();
1176 }
1177
1178 static bool isDisplayFlexibleBox(EDisplay display)
1179 {
1180     return display == FLEX || display == INLINE_FLEX;
1181 }
1182
1183 #if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
1184 static bool isScrollableOverflow(EOverflow overflow)
1185 {
1186     return overflow == OSCROLL || overflow == OAUTO || overflow == OOVERLAY;
1187 }
1188 #endif
1189
1190 void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& parentStyle, Element *e)
1191 {
1192     // Cache our original display.
1193     style.setOriginalDisplay(style.display());
1194
1195     if (style.display() != NONE) {
1196         // If we have a <td> that specifies a float property, in quirks mode we just drop the float
1197         // property.
1198         // Sites also commonly use display:inline/block on <td>s and <table>s. In quirks mode we force
1199         // these tags to retain their display types.
1200         if (document().inQuirksMode() && e) {
1201             if (e->hasTagName(tdTag)) {
1202                 style.setDisplay(TABLE_CELL);
1203                 style.setFloating(NoFloat);
1204             } else if (isHTMLTableElement(e))
1205                 style.setDisplay(style.isDisplayInlineType() ? INLINE_TABLE : TABLE);
1206         }
1207
1208         if (e && (e->hasTagName(tdTag) || e->hasTagName(thTag))) {
1209             if (style.whiteSpace() == KHTML_NOWRAP) {
1210                 // Figure out if we are really nowrapping or if we should just
1211                 // use normal instead. If the width of the cell is fixed, then
1212                 // we don't actually use NOWRAP.
1213                 if (style.width().isFixed())
1214                     style.setWhiteSpace(NORMAL);
1215                 else
1216                     style.setWhiteSpace(NOWRAP);
1217             }
1218         }
1219
1220         // Tables never support the -webkit-* values for text-align and will reset back to the default.
1221         if (e && isHTMLTableElement(e) && (style.textAlign() == WEBKIT_LEFT || style.textAlign() == WEBKIT_CENTER || style.textAlign() == WEBKIT_RIGHT))
1222             style.setTextAlign(TASTART);
1223
1224         // Frames and framesets never honor position:relative or position:absolute. This is necessary to
1225         // fix a crash where a site tries to position these objects. They also never honor display.
1226         if (e && (e->hasTagName(frameTag) || e->hasTagName(framesetTag))) {
1227             style.setPosition(StaticPosition);
1228             style.setDisplay(BLOCK);
1229         }
1230
1231         // Ruby text does not support float or position. This might change with evolution of the specification.
1232         if (e && e->hasTagName(rtTag)) {
1233             style.setPosition(StaticPosition);
1234             style.setFloating(NoFloat);
1235         }
1236
1237         // FIXME: We shouldn't be overriding start/-webkit-auto like this. Do it in html.css instead.
1238         // Table headers with a text-align of -webkit-auto will change the text-align to center.
1239         if (e && e->hasTagName(thTag) && style.textAlign() == TASTART)
1240             style.setTextAlign(CENTER);
1241
1242         if (e && e->hasTagName(legendTag))
1243             style.setDisplay(BLOCK);
1244
1245         // Absolute/fixed positioned elements, floating elements and the document element need block-like outside display.
1246         if (style.hasOutOfFlowPosition() || style.isFloating() || (e && e->document().documentElement() == e))
1247             style.setDisplay(equivalentBlockDisplay(style.display(), style.isFloating(), !document().inQuirksMode()));
1248
1249         // FIXME: Don't support this mutation for pseudo styles like first-letter or first-line, since it's not completely
1250         // clear how that should work.
1251         if (style.display() == INLINE && style.styleType() == NOPSEUDO && style.writingMode() != parentStyle.writingMode())
1252             style.setDisplay(INLINE_BLOCK);
1253
1254         // After performing the display mutation, check table rows. We do not honor position:relative or position:sticky on
1255         // table rows or cells. This has been established for position:relative in CSS2.1 (and caused a crash in containingBlock()
1256         // on some sites).
1257         if ((style.display() == TABLE_HEADER_GROUP || style.display() == TABLE_ROW_GROUP
1258             || style.display() == TABLE_FOOTER_GROUP || style.display() == TABLE_ROW)
1259             && style.hasInFlowPosition())
1260             style.setPosition(StaticPosition);
1261
1262         // writing-mode does not apply to table row groups, table column groups, table rows, and table columns.
1263         // FIXME: Table cells should be allowed to be perpendicular or flipped with respect to the table, though.
1264         if (style.display() == TABLE_COLUMN || style.display() == TABLE_COLUMN_GROUP || style.display() == TABLE_FOOTER_GROUP
1265             || style.display() == TABLE_HEADER_GROUP || style.display() == TABLE_ROW || style.display() == TABLE_ROW_GROUP
1266             || style.display() == TABLE_CELL)
1267             style.setWritingMode(parentStyle.writingMode());
1268
1269         // FIXME: Since we don't support block-flow on flexible boxes yet, disallow setting
1270         // of block-flow to anything other than TopToBottomWritingMode.
1271         // https://bugs.webkit.org/show_bug.cgi?id=46418 - Flexible box support.
1272         if (style.writingMode() != TopToBottomWritingMode && (style.display() == BOX || style.display() == INLINE_BOX))
1273             style.setWritingMode(TopToBottomWritingMode);
1274
1275         if (isDisplayFlexibleBox(parentStyle.display())) {
1276             style.setFloating(NoFloat);
1277             style.setDisplay(equivalentBlockDisplay(style.display(), style.isFloating(), !document().inQuirksMode()));
1278         }
1279     }
1280
1281     // Make sure our z-index value is only applied if the object is positioned.
1282     if (style.position() == StaticPosition && !isDisplayFlexibleBox(parentStyle.display()))
1283         style.setHasAutoZIndex();
1284
1285     // Auto z-index becomes 0 for the root element and transparent objects. This prevents
1286     // cases where objects that should be blended as a single unit end up with a non-transparent
1287     // object wedged in between them. Auto z-index also becomes 0 for objects that specify transforms/masks/reflections.
1288     if (style.hasAutoZIndex() && ((e && e->document().documentElement() == e)
1289         || style.opacity() < 1.0f
1290         || style.hasTransformRelatedProperty()
1291         || style.hasMask()
1292         || style.clipPath()
1293         || style.boxReflect()
1294         || style.hasFilter()
1295         || style.hasBlendMode()
1296         || style.position() == StickyPosition
1297         || (style.position() == FixedPosition && e && e->document().page() && e->document().page()->settings().fixedPositionCreatesStackingContext())
1298         || style.hasFlowFrom()
1299         ))
1300         style.setZIndex(0);
1301
1302     // Textarea considers overflow visible as auto.
1303     if (e && isHTMLTextAreaElement(e)) {
1304         style.setOverflowX(style.overflowX() == OVISIBLE ? OAUTO : style.overflowX());
1305         style.setOverflowY(style.overflowY() == OVISIBLE ? OAUTO : style.overflowY());
1306     }
1307
1308     if (doesNotInheritTextDecoration(style, e))
1309         style.setTextDecorationsInEffect(style.textDecoration());
1310     else
1311         style.addToTextDecorationsInEffect(style.textDecoration());
1312
1313     // If either overflow value is not visible, change to auto.
1314     if (style.overflowX() == OMARQUEE && style.overflowY() != OMARQUEE)
1315         style.setOverflowY(OMARQUEE);
1316     else if (style.overflowY() == OMARQUEE && style.overflowX() != OMARQUEE)
1317         style.setOverflowX(OMARQUEE);
1318     else if (style.overflowX() == OVISIBLE && style.overflowY() != OVISIBLE) {
1319         // FIXME: Once we implement pagination controls, overflow-x should default to hidden
1320         // if overflow-y is set to -webkit-paged-x or -webkit-page-y. For now, we'll let it
1321         // default to auto so we can at least scroll through the pages.
1322         style.setOverflowX(OAUTO);
1323     } else if (style.overflowY() == OVISIBLE && style.overflowX() != OVISIBLE)
1324         style.setOverflowY(OAUTO);
1325
1326     // Call setStylesForPaginationMode() if a pagination mode is set for any non-root elements. If these
1327     // styles are specified on a root element, then they will be incorporated in
1328     // Style::createForDocument().
1329     if ((style.overflowY() == OPAGEDX || style.overflowY() == OPAGEDY) && !(e && (e->hasTagName(htmlTag) || e->hasTagName(bodyTag))))
1330         style.setColumnStylesFromPaginationMode(WebCore::paginationModeForRenderStyle(style));
1331
1332     // Table rows, sections and the table itself will support overflow:hidden and will ignore scroll/auto.
1333     // FIXME: Eventually table sections will support auto and scroll.
1334     if (style.display() == TABLE || style.display() == INLINE_TABLE
1335         || style.display() == TABLE_ROW_GROUP || style.display() == TABLE_ROW) {
1336         if (style.overflowX() != OVISIBLE && style.overflowX() != OHIDDEN)
1337             style.setOverflowX(OVISIBLE);
1338         if (style.overflowY() != OVISIBLE && style.overflowY() != OHIDDEN)
1339             style.setOverflowY(OVISIBLE);
1340     }
1341
1342     // Menulists should have visible overflow
1343     if (style.appearance() == MenulistPart) {
1344         style.setOverflowX(OVISIBLE);
1345         style.setOverflowY(OVISIBLE);
1346     }
1347
1348 #if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
1349     // Touch overflow scrolling creates a stacking context.
1350     if (style.hasAutoZIndex() && style.useTouchOverflowScrolling() && (isScrollableOverflow(style.overflowX()) || isScrollableOverflow(style.overflowY())))
1351         style.setZIndex(0);
1352 #endif
1353
1354     // Cull out any useless layers and also repeat patterns into additional layers.
1355     style.adjustBackgroundLayers();
1356     style.adjustMaskLayers();
1357
1358     // Do the same for animations and transitions.
1359     style.adjustAnimations();
1360     style.adjustTransitions();
1361
1362     // Important: Intrinsic margins get added to controls before the theme has adjusted the style, since the theme will
1363     // alter fonts and heights/widths.
1364     if (e && e->isFormControlElement() && style.fontSize() >= 11) {
1365         // Don't apply intrinsic margins to image buttons. The designer knows how big the images are,
1366         // so we have to treat all image buttons as though they were explicitly sized.
1367         if (!isHTMLInputElement(e) || !toHTMLInputElement(e)->isImageButton())
1368             addIntrinsicMargins(style);
1369     }
1370
1371     // Let the theme also have a crack at adjusting the style.
1372     if (style.hasAppearance())
1373         RenderTheme::defaultTheme()->adjustStyle(*this, style, e, m_state.hasUAAppearance(), m_state.borderData(), m_state.backgroundData(), m_state.backgroundColor());
1374
1375     // If we have first-letter pseudo style, do not share this style.
1376     if (style.hasPseudoStyle(FIRST_LETTER))
1377         style.setUnique();
1378
1379     // FIXME: when dropping the -webkit prefix on transform-style, we should also have opacity < 1 cause flattening.
1380     if (style.preserves3D() && (style.overflowX() != OVISIBLE
1381         || style.overflowY() != OVISIBLE
1382         || style.hasFilter()))
1383         style.setTransformStyle3D(TransformStyle3DFlat);
1384
1385     // Seamless iframes behave like blocks. Map their display to inline-block when marked inline.
1386     if (e && e->hasTagName(iframeTag) && style.display() == INLINE && toHTMLIFrameElement(e)->shouldDisplaySeamlessly())
1387         style.setDisplay(INLINE_BLOCK);
1388
1389     adjustGridItemPosition(style, parentStyle);
1390
1391 #if ENABLE(SVG)
1392     if (e && e->isSVGElement()) {
1393         // Spec: http://www.w3.org/TR/SVG/masking.html#OverflowProperty
1394         if (style.overflowY() == OSCROLL)
1395             style.setOverflowY(OHIDDEN);
1396         else if (style.overflowY() == OAUTO)
1397             style.setOverflowY(OVISIBLE);
1398
1399         if (style.overflowX() == OSCROLL)
1400             style.setOverflowX(OHIDDEN);
1401         else if (style.overflowX() == OAUTO)
1402             style.setOverflowX(OVISIBLE);
1403
1404         // Only the root <svg> element in an SVG document fragment tree honors css position
1405         if (!(e->hasTagName(SVGNames::svgTag) && e->parentNode() && !e->parentNode()->isSVGElement()))
1406             style.setPosition(RenderStyle::initialPosition());
1407
1408         // RenderSVGRoot handles zooming for the whole SVG subtree, so foreignObject content should
1409         // not be scaled again.
1410         if (e->hasTagName(SVGNames::foreignObjectTag))
1411             style.setEffectiveZoom(RenderStyle::initialZoom());
1412     }
1413 #endif
1414 }
1415
1416 void StyleResolver::adjustGridItemPosition(RenderStyle& style, const RenderStyle& parentStyle) const
1417 {
1418     const GridPosition& columnStartPosition = style.gridItemColumnStart();
1419     const GridPosition& columnEndPosition = style.gridItemColumnEnd();
1420     const GridPosition& rowStartPosition = style.gridItemRowStart();
1421     const GridPosition& rowEndPosition = style.gridItemRowEnd();
1422
1423     // If opposing grid-placement properties both specify a grid span, they both compute to ‘auto’.
1424     if (columnStartPosition.isSpan() && columnEndPosition.isSpan()) {
1425         style.setGridItemColumnStart(GridPosition());
1426         style.setGridItemColumnEnd(GridPosition());
1427     }
1428
1429     if (rowStartPosition.isSpan() && rowEndPosition.isSpan()) {
1430         style.setGridItemRowStart(GridPosition());
1431         style.setGridItemRowEnd(GridPosition());
1432     }
1433
1434     // Unknown named grid area compute to 'auto'.
1435     const NamedGridAreaMap& map = parentStyle.namedGridArea();
1436
1437 #define CLEAR_UNKNOWN_NAMED_AREA(prop, Prop) \
1438     if (prop.isNamedGridArea() && !map.contains(prop.namedGridLine())) \
1439         style.setGridItem##Prop(GridPosition());
1440
1441     CLEAR_UNKNOWN_NAMED_AREA(columnStartPosition, ColumnStart);
1442     CLEAR_UNKNOWN_NAMED_AREA(columnEndPosition, ColumnEnd);
1443     CLEAR_UNKNOWN_NAMED_AREA(rowStartPosition, RowStart);
1444     CLEAR_UNKNOWN_NAMED_AREA(rowEndPosition, RowEnd);
1445 }
1446
1447 bool StyleResolver::checkRegionStyle(Element* regionElement)
1448 {
1449     // FIXME (BUG 72472): We don't add @-webkit-region rules of scoped style sheets for the moment,
1450     // so all region rules are global by default. Verify whether that can stand or needs changing.
1451
1452     unsigned rulesSize = m_ruleSets.authorStyle()->regionSelectorsAndRuleSets().size();
1453     for (unsigned i = 0; i < rulesSize; ++i) {
1454         ASSERT(m_ruleSets.authorStyle()->regionSelectorsAndRuleSets().at(i).ruleSet.get());
1455         if (checkRegionSelector(m_ruleSets.authorStyle()->regionSelectorsAndRuleSets().at(i).selector, regionElement))
1456             return true;
1457     }
1458
1459     if (m_ruleSets.userStyle()) {
1460         rulesSize = m_ruleSets.userStyle()->regionSelectorsAndRuleSets().size();
1461         for (unsigned i = 0; i < rulesSize; ++i) {
1462             ASSERT(m_ruleSets.userStyle()->regionSelectorsAndRuleSets().at(i).ruleSet.get());
1463             if (checkRegionSelector(m_ruleSets.userStyle()->regionSelectorsAndRuleSets().at(i).selector, regionElement))
1464                 return true;
1465         }
1466     }
1467
1468     return false;
1469 }
1470
1471 static void checkForOrientationChange(RenderStyle* style)
1472 {
1473     FontOrientation fontOrientation;
1474     NonCJKGlyphOrientation glyphOrientation;
1475     style->getFontAndGlyphOrientation(fontOrientation, glyphOrientation);
1476
1477     const FontDescription& fontDescription = style->fontDescription();
1478     if (fontDescription.orientation() == fontOrientation && fontDescription.nonCJKGlyphOrientation() == glyphOrientation)
1479         return;
1480
1481     FontDescription newFontDescription(fontDescription);
1482     newFontDescription.setNonCJKGlyphOrientation(glyphOrientation);
1483     newFontDescription.setOrientation(fontOrientation);
1484     style->setFontDescription(newFontDescription);
1485 }
1486
1487 void StyleResolver::updateFont()
1488 {
1489     if (!m_state.fontDirty())
1490         return;
1491
1492     RenderStyle* style = m_state.style();
1493 #if ENABLE(IOS_TEXT_AUTOSIZING)
1494     checkForTextSizeAdjust(style);
1495 #endif
1496     checkForGenericFamilyChange(style, m_state.parentStyle());
1497     checkForZoomChange(style, m_state.parentStyle());
1498     checkForOrientationChange(style);
1499     style->font().update(m_fontSelector);
1500     m_state.setFontDirty(false);
1501 }
1502
1503 Vector<RefPtr<StyleRuleBase>> StyleResolver::styleRulesForElement(Element* e, unsigned rulesToInclude)
1504 {
1505     return pseudoStyleRulesForElement(e, NOPSEUDO, rulesToInclude);
1506 }
1507
1508 Vector<RefPtr<StyleRuleBase>> StyleResolver::pseudoStyleRulesForElement(Element* e, PseudoId pseudoId, unsigned rulesToInclude)
1509 {
1510     if (!e || !e->document().haveStylesheetsLoaded())
1511         return Vector<RefPtr<StyleRuleBase>>();
1512
1513     initElement(e);
1514     m_state.initForStyleResolve(document(), e, 0);
1515
1516     ElementRuleCollector collector(this, m_state);
1517     collector.setMode(SelectorChecker::CollectingRules);
1518     collector.setPseudoStyleRequest(PseudoStyleRequest(pseudoId));
1519     collector.setMedium(m_medium.get());
1520
1521     if (rulesToInclude & UAAndUserCSSRules) {
1522         // First we match rules from the user agent sheet.
1523         collector.matchUARules();
1524         
1525         // Now we check user sheet rules.
1526         if (m_matchAuthorAndUserStyles)
1527             collector.matchUserRules(rulesToInclude & EmptyCSSRules);
1528     }
1529
1530     if (m_matchAuthorAndUserStyles && (rulesToInclude & AuthorCSSRules)) {
1531         collector.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
1532
1533         // Check the rules in author sheets.
1534         collector.matchAuthorRules(rulesToInclude & EmptyCSSRules);
1535     }
1536
1537     return collector.matchedRuleList();
1538 }
1539
1540 // -------------------------------------------------------------------------------------
1541 // this is mostly boring stuff on how to apply a certain rule to the renderstyle...
1542
1543 Length StyleResolver::convertToIntLength(const CSSPrimitiveValue* primitiveValue, const RenderStyle* style, const RenderStyle* rootStyle, double multiplier)
1544 {
1545     return primitiveValue ? primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
1546 }
1547
1548 Length StyleResolver::convertToFloatLength(const CSSPrimitiveValue* primitiveValue, const RenderStyle* style, const RenderStyle* rootStyle, double multiplier)
1549 {
1550     return primitiveValue ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
1551 }
1552
1553 template <StyleResolver::StyleApplicationPass pass>
1554 void StyleResolver::applyProperties(const StyleProperties* properties, StyleRule* rule, bool isImportant, bool inheritedOnly, PropertyWhitelistType propertyWhitelistType)
1555 {
1556     ASSERT((propertyWhitelistType != PropertyWhitelistRegion) || m_state.regionForStyling());
1557     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willProcessRule(&document(), rule, *this);
1558
1559     unsigned propertyCount = properties->propertyCount();
1560     for (unsigned i = 0; i < propertyCount; ++i) {
1561         StyleProperties::PropertyReference current = properties->propertyAt(i);
1562         if (isImportant != current.isImportant())
1563             continue;
1564         if (inheritedOnly && !current.isInherited()) {
1565             // If the property value is explicitly inherited, we need to apply further non-inherited properties
1566             // as they might override the value inherited here. For this reason we don't allow declarations with
1567             // explicitly inherited properties to be cached.
1568             ASSERT(!current.value()->isInheritedValue());
1569             continue;
1570         }
1571         CSSPropertyID property = current.id();
1572
1573         if (propertyWhitelistType == PropertyWhitelistRegion && !StyleResolver::isValidRegionStyleProperty(property))
1574             continue;
1575 #if ENABLE(VIDEO_TRACK)
1576         if (propertyWhitelistType == PropertyWhitelistCue && !StyleResolver::isValidCueStyleProperty(property))
1577             continue;
1578 #endif
1579         switch (pass) {
1580         case HighPriorityProperties:
1581             COMPILE_ASSERT(firstCSSProperty == CSSPropertyColor, CSS_color_is_first_property);
1582 #if ENABLE(IOS_TEXT_AUTOSIZING)
1583             COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 18, CSS_zoom_is_end_of_first_prop_range);
1584 #else
1585             COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 17, CSS_zoom_is_end_of_first_prop_range);
1586 #endif
1587             COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyZoom + 1, CSS_line_height_is_after_zoom);
1588             // give special priority to font-xxx, color properties, etc
1589             if (property < CSSPropertyLineHeight)
1590                 applyProperty(current.id(), current.value());
1591             // we apply line-height later
1592             else if (property == CSSPropertyLineHeight)
1593                 m_state.setLineHeightValue(current.value());
1594             break;
1595         case LowPriorityProperties:
1596             if (property > CSSPropertyLineHeight)
1597                 applyProperty(current.id(), current.value());
1598         }
1599     }
1600     InspectorInstrumentation::didProcessRule(cookie);
1601 }
1602
1603 static bool shouldApplyPropertyInParseOrder(CSSPropertyID propertyID)
1604 {
1605     switch (propertyID) {
1606     case CSSPropertyWebkitBorderImage:
1607     case CSSPropertyBorderImage:
1608     case CSSPropertyBorderImageSlice:
1609     case CSSPropertyBorderImageSource:
1610     case CSSPropertyBorderImageOutset:
1611     case CSSPropertyBorderImageRepeat:
1612     case CSSPropertyBorderImageWidth:
1613 #if ENABLE(CSS3_TEXT_DECORATION)
1614     case CSSPropertyWebkitTextDecoration:
1615     case CSSPropertyWebkitTextDecorationLine:
1616     case CSSPropertyWebkitTextDecorationStyle:
1617     case CSSPropertyWebkitTextDecorationColor:
1618     case CSSPropertyWebkitTextDecorationSkip:
1619     case CSSPropertyWebkitTextUnderlinePosition:
1620 #endif
1621     case CSSPropertyTextDecoration:
1622         return true;
1623     default:
1624         return false;
1625     }
1626 }
1627
1628 static bool elementTypeHasAppearanceFromUAStyle(const Element& element)
1629 {
1630     // NOTE: This is just a hard-coded list of elements that have some -webkit-appearance value in html.css
1631     const auto& localName = element.localName();
1632     return localName == HTMLNames::inputTag
1633         || localName == HTMLNames::textareaTag
1634         || localName == HTMLNames::buttonTag
1635         || localName == HTMLNames::progressTag
1636         || localName == HTMLNames::selectTag
1637         || localName == HTMLNames::meterTag
1638         || localName == HTMLNames::isindexTag;
1639 }
1640
1641 template <StyleResolver::StyleApplicationPass pass>
1642 void StyleResolver::applyMatchedProperties(const MatchResult& matchResult, bool isImportant, int startIndex, int endIndex, bool inheritedOnly)
1643 {
1644     if (startIndex == -1)
1645         return;
1646
1647     State& state = m_state;
1648     if (state.style()->insideLink() != NotInsideLink) {
1649         for (int i = startIndex; i <= endIndex; ++i) {
1650             const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
1651             unsigned linkMatchType = matchedProperties.linkMatchType;
1652             // FIXME: It would be nicer to pass these as arguments but that requires changes in many places.
1653             state.setApplyPropertyToRegularStyle(linkMatchType & SelectorChecker::MatchLink);
1654             state.setApplyPropertyToVisitedLinkStyle(linkMatchType & SelectorChecker::MatchVisited);
1655
1656             applyProperties<pass>(matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, static_cast<PropertyWhitelistType>(matchedProperties.whitelistType));
1657         }
1658         state.setApplyPropertyToRegularStyle(true);
1659         state.setApplyPropertyToVisitedLinkStyle(false);
1660         return;
1661     }
1662     for (int i = startIndex; i <= endIndex; ++i) {
1663         const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
1664         applyProperties<pass>(matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, static_cast<PropertyWhitelistType>(matchedProperties.whitelistType));
1665     }
1666 }
1667
1668 unsigned StyleResolver::computeMatchedPropertiesHash(const MatchedProperties* properties, unsigned size)
1669 {
1670     
1671     return StringHasher::hashMemory(properties, sizeof(MatchedProperties) * size);
1672 }
1673
1674 bool operator==(const StyleResolver::MatchRanges& a, const StyleResolver::MatchRanges& b)
1675 {
1676     return a.firstUARule == b.firstUARule
1677         && a.lastUARule == b.lastUARule
1678         && a.firstAuthorRule == b.firstAuthorRule
1679         && a.lastAuthorRule == b.lastAuthorRule
1680         && a.firstUserRule == b.firstUserRule
1681         && a.lastUserRule == b.lastUserRule;
1682 }
1683
1684 bool operator!=(const StyleResolver::MatchRanges& a, const StyleResolver::MatchRanges& b)
1685 {
1686     return !(a == b);
1687 }
1688
1689 bool operator==(const StyleResolver::MatchedProperties& a, const StyleResolver::MatchedProperties& b)
1690 {
1691     return a.properties == b.properties && a.linkMatchType == b.linkMatchType;
1692 }
1693
1694 bool operator!=(const StyleResolver::MatchedProperties& a, const StyleResolver::MatchedProperties& b)
1695 {
1696     return !(a == b);
1697 }
1698
1699 const StyleResolver::MatchedPropertiesCacheItem* StyleResolver::findFromMatchedPropertiesCache(unsigned hash, const MatchResult& matchResult)
1700 {
1701     ASSERT(hash);
1702
1703     MatchedPropertiesCache::iterator it = m_matchedPropertiesCache.find(hash);
1704     if (it == m_matchedPropertiesCache.end())
1705         return 0;
1706     MatchedPropertiesCacheItem& cacheItem = it->value;
1707
1708     size_t size = matchResult.matchedProperties.size();
1709     if (size != cacheItem.matchedProperties.size())
1710         return 0;
1711     for (size_t i = 0; i < size; ++i) {
1712         if (matchResult.matchedProperties[i] != cacheItem.matchedProperties[i])
1713             return 0;
1714     }
1715     if (cacheItem.ranges != matchResult.ranges)
1716         return 0;
1717     return &cacheItem;
1718 }
1719
1720 void StyleResolver::addToMatchedPropertiesCache(const RenderStyle* style, const RenderStyle* parentStyle, unsigned hash, const MatchResult& matchResult)
1721 {
1722     static const unsigned matchedDeclarationCacheAdditionsBetweenSweeps = 100;
1723     if (++m_matchedPropertiesCacheAdditionsSinceLastSweep >= matchedDeclarationCacheAdditionsBetweenSweeps
1724         && !m_matchedPropertiesCacheSweepTimer.isActive()) {
1725         static const unsigned matchedDeclarationCacheSweepTimeInSeconds = 60;
1726         m_matchedPropertiesCacheSweepTimer.startOneShot(matchedDeclarationCacheSweepTimeInSeconds);
1727     }
1728
1729     ASSERT(hash);
1730     MatchedPropertiesCacheItem cacheItem;
1731     cacheItem.matchedProperties.appendVector(matchResult.matchedProperties);
1732     cacheItem.ranges = matchResult.ranges;
1733     // Note that we don't cache the original RenderStyle instance. It may be further modified.
1734     // The RenderStyle in the cache is really just a holder for the substructures and never used as-is.
1735     cacheItem.renderStyle = RenderStyle::clone(style);
1736     cacheItem.parentRenderStyle = RenderStyle::clone(parentStyle);
1737     m_matchedPropertiesCache.add(hash, cacheItem);
1738 }
1739
1740 void StyleResolver::invalidateMatchedPropertiesCache()
1741 {
1742     m_matchedPropertiesCache.clear();
1743 }
1744
1745 static bool isCacheableInMatchedPropertiesCache(const Element* element, const RenderStyle* style, const RenderStyle* parentStyle)
1746 {
1747     // FIXME: CSSPropertyWebkitWritingMode modifies state when applying to document element. We can't skip the applying by caching.
1748     if (element == element->document().documentElement() && element->document().writingModeSetOnDocumentElement())
1749         return false;
1750     if (style->unique() || (style->styleType() != NOPSEUDO && parentStyle->unique()))
1751         return false;
1752     if (style->hasAppearance())
1753         return false;
1754     if (style->zoom() != RenderStyle::initialZoom())
1755         return false;
1756     if (style->writingMode() != RenderStyle::initialWritingMode())
1757         return false;
1758     // The cache assumes static knowledge about which properties are inherited.
1759     if (parentStyle->hasExplicitlyInheritedProperties())
1760         return false;
1761     return true;
1762 }
1763
1764 static void extractDirectionAndWritingMode(const RenderStyle& style, const StyleResolver::MatchResult& matchResult, TextDirection& direction, WritingMode& writingMode)
1765 {
1766     direction = style.direction();
1767     writingMode = style.writingMode();
1768
1769     bool hadImportantWebkitWritingMode = false;
1770     bool hadImportantDirection = false;
1771
1772     for (auto& matchedProperties : matchResult.matchedProperties) {
1773         for (unsigned i = 0, count = matchedProperties.properties->propertyCount(); i < count; ++i) {
1774             auto property = matchedProperties.properties->propertyAt(i);
1775             if (!property.value()->isPrimitiveValue())
1776                 continue;
1777             switch (property.id()) {
1778             case CSSPropertyWebkitWritingMode:
1779                 if (!hadImportantWebkitWritingMode || property.isImportant()) {
1780                     writingMode = toCSSPrimitiveValue(*property.value());
1781                     hadImportantWebkitWritingMode = property.isImportant();
1782                 }
1783                 break;
1784             case CSSPropertyDirection:
1785                 if (!hadImportantDirection || property.isImportant()) {
1786                     direction = toCSSPrimitiveValue(*property.value());
1787                     hadImportantDirection = property.isImportant();
1788                 }
1789                 break;
1790             default:
1791                 break;
1792             }
1793         }
1794     }
1795 }
1796
1797 void StyleResolver::applyMatchedProperties(const MatchResult& matchResult, const Element* element, ShouldUseMatchedPropertiesCache shouldUseMatchedPropertiesCache)
1798 {
1799     ASSERT(element);
1800     State& state = m_state;
1801     unsigned cacheHash = matchResult.isCacheable ? computeMatchedPropertiesHash(matchResult.matchedProperties.data(), matchResult.matchedProperties.size()) : 0;
1802     bool applyInheritedOnly = false;
1803     const MatchedPropertiesCacheItem* cacheItem = 0;
1804     if (shouldUseMatchedPropertiesCache && cacheHash && (cacheItem = findFromMatchedPropertiesCache(cacheHash, matchResult))) {
1805         // We can build up the style by copying non-inherited properties from an earlier style object built using the same exact
1806         // style declarations. We then only need to apply the inherited properties, if any, as their values can depend on the 
1807         // element context. This is fast and saves memory by reusing the style data structures.
1808         state.style()->copyNonInheritedFrom(cacheItem->renderStyle.get());
1809         if (state.parentStyle()->inheritedDataShared(cacheItem->parentRenderStyle.get()) && !isAtShadowBoundary(element)) {
1810             EInsideLink linkStatus = state.style()->insideLink();
1811             // If the cache item parent style has identical inherited properties to the current parent style then the
1812             // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
1813             state.style()->inheritFrom(cacheItem->renderStyle.get());
1814
1815             // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
1816             state.style()->setInsideLink(linkStatus);
1817             return;
1818         }
1819         applyInheritedOnly = true; 
1820     }
1821
1822     // Directional properties (*-before/after) are aliases that depend on the TextDirection and WritingMode.
1823     // These must be resolved before we can begin the property cascade.
1824     TextDirection direction;
1825     WritingMode writingMode;
1826     extractDirectionAndWritingMode(*state.style(), matchResult, direction, writingMode);
1827
1828     if (elementTypeHasAppearanceFromUAStyle(*state.element())) {
1829         // FIXME: This is such a hack.
1830         // Find out if there's a -webkit-appearance property in effect from the UA sheet.
1831         // If so, we cache the border and background styles so that RenderTheme::adjustStyle()
1832         // can look at them later to figure out if this is a styled form control or not.
1833         state.setLineHeightValue(nullptr);
1834         CascadedProperties cascade(direction, writingMode);
1835         cascade.addMatches(matchResult, false, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
1836         cascade.addMatches(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
1837
1838         applyCascadedProperties(cascade, firstCSSProperty, CSSPropertyLineHeight);
1839         updateFont();
1840         applyCascadedProperties(cascade, CSSPropertyBackground, lastCSSProperty);
1841
1842         state.cacheBorderAndBackground();
1843     }
1844
1845     CascadedProperties cascade(direction, writingMode);
1846     cascade.addMatches(matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
1847     cascade.addMatches(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
1848     cascade.addMatches(matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
1849     cascade.addMatches(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
1850
1851     state.setLineHeightValue(nullptr);
1852
1853     // Start by applying properties that other properties may depend on.
1854     applyCascadedProperties(cascade, firstCSSProperty, CSSPropertyLineHeight);
1855
1856     // If the effective zoom value changes, we can't use the matched properties cache. Start over.
1857     if (cacheItem && cacheItem->renderStyle->effectiveZoom() != state.style()->effectiveZoom())
1858         return applyMatchedProperties(matchResult, element, DoNotUseMatchedPropertiesCache);
1859
1860     // If our font got dirtied, go ahead and update it now.
1861     updateFont();
1862
1863     // Line-height is set when we are sure we decided on the font-size.
1864     if (state.lineHeightValue())
1865         applyProperty(CSSPropertyLineHeight, state.lineHeightValue());
1866
1867     // If the font changed, we can't use the matched properties cache. Start over.
1868     if (cacheItem && cacheItem->renderStyle->fontDescription() != state.style()->fontDescription())
1869         return applyMatchedProperties(matchResult, element, DoNotUseMatchedPropertiesCache);
1870
1871     // Apply properties that no other properties depend on.
1872     applyCascadedProperties(cascade, CSSPropertyBackground, lastCSSProperty);
1873
1874     // Finally, some properties must be applied in the order they were parsed.
1875     // There are some CSS properties that affect the same RenderStyle values,
1876     // so to preserve behavior, we queue them up during cascade and flush here.
1877     cascade.applyDeferredProperties(*this);
1878
1879     // Start loading resources referenced by this style.
1880     loadPendingResources();
1881     
1882     ASSERT(!state.fontDirty());
1883     
1884     if (cacheItem || !cacheHash)
1885         return;
1886     if (!isCacheableInMatchedPropertiesCache(state.element(), state.style(), state.parentStyle()))
1887         return;
1888     addToMatchedPropertiesCache(state.style(), state.parentStyle(), cacheHash, matchResult);
1889 }
1890
1891 void StyleResolver::applyPropertyToStyle(CSSPropertyID id, CSSValue* value, RenderStyle* style)
1892 {
1893     initElement(0);
1894     m_state.initForStyleResolve(document(), 0, style);
1895     m_state.setStyle(*style);
1896     applyPropertyToCurrentStyle(id, value);
1897 }
1898
1899 void StyleResolver::applyPropertyToCurrentStyle(CSSPropertyID id, CSSValue* value)
1900 {
1901     if (value)
1902         applyProperty(id, value);
1903 }
1904
1905 inline bool isValidVisitedLinkProperty(CSSPropertyID id)
1906 {
1907     switch (id) {
1908     case CSSPropertyBackgroundColor:
1909     case CSSPropertyBorderLeftColor:
1910     case CSSPropertyBorderRightColor:
1911     case CSSPropertyBorderTopColor:
1912     case CSSPropertyBorderBottomColor:
1913     case CSSPropertyColor:
1914     case CSSPropertyOutlineColor:
1915     case CSSPropertyWebkitColumnRuleColor:
1916 #if ENABLE(CSS3_TEXT_DECORATION)
1917     case CSSPropertyWebkitTextDecorationColor:
1918 #endif
1919     case CSSPropertyWebkitTextEmphasisColor:
1920     case CSSPropertyWebkitTextFillColor:
1921     case CSSPropertyWebkitTextStrokeColor:
1922 #if ENABLE(SVG)
1923     case CSSPropertyFill:
1924     case CSSPropertyStroke:
1925 #endif
1926         return true;
1927     default:
1928         break;
1929     }
1930
1931     return false;
1932 }
1933
1934 // http://dev.w3.org/csswg/css3-regions/#the-at-region-style-rule
1935 // FIXME: add incremental support for other region styling properties.
1936 inline bool StyleResolver::isValidRegionStyleProperty(CSSPropertyID id)
1937 {
1938     switch (id) {
1939     case CSSPropertyBackgroundColor:
1940     case CSSPropertyColor:
1941         return true;
1942     default:
1943         break;
1944     }
1945
1946     return false;
1947 }
1948
1949 #if ENABLE(VIDEO_TRACK)
1950 inline bool StyleResolver::isValidCueStyleProperty(CSSPropertyID id)
1951 {
1952     switch (id) {
1953     case CSSPropertyBackground:
1954     case CSSPropertyBackgroundAttachment:
1955     case CSSPropertyBackgroundClip:
1956     case CSSPropertyBackgroundColor:
1957     case CSSPropertyBackgroundImage:
1958     case CSSPropertyBackgroundOrigin:
1959     case CSSPropertyBackgroundPosition:
1960     case CSSPropertyBackgroundPositionX:
1961     case CSSPropertyBackgroundPositionY:
1962     case CSSPropertyBackgroundRepeat:
1963     case CSSPropertyBackgroundRepeatX:
1964     case CSSPropertyBackgroundRepeatY:
1965     case CSSPropertyBackgroundSize:
1966     case CSSPropertyColor:
1967     case CSSPropertyFont:
1968     case CSSPropertyFontFamily:
1969     case CSSPropertyFontSize:
1970     case CSSPropertyFontStyle:
1971     case CSSPropertyFontVariant:
1972     case CSSPropertyFontWeight:
1973     case CSSPropertyLineHeight:
1974     case CSSPropertyOpacity:
1975     case CSSPropertyOutline:
1976     case CSSPropertyOutlineColor:
1977     case CSSPropertyOutlineOffset:
1978     case CSSPropertyOutlineStyle:
1979     case CSSPropertyOutlineWidth:
1980     case CSSPropertyVisibility:
1981     case CSSPropertyWhiteSpace:
1982     case CSSPropertyTextDecoration:
1983     case CSSPropertyTextShadow:
1984     case CSSPropertyBorderStyle:
1985         return true;
1986     default:
1987         break;
1988     }
1989     return false;
1990 }
1991 #endif
1992 // SVG handles zooming in a different way compared to CSS. The whole document is scaled instead
1993 // of each individual length value in the render style / tree. CSSPrimitiveValue::computeLength*()
1994 // multiplies each resolved length with the zoom multiplier - so for SVG we need to disable that.
1995 // Though all CSS values that can be applied to outermost <svg> elements (width/height/border/padding...)
1996 // need to respect the scaling. RenderBox (the parent class of RenderSVGRoot) grabs values like
1997 // width/height/border/padding/... from the RenderStyle -> for SVG these values would never scale,
1998 // if we'd pass a 1.0 zoom factor everyhwere. So we only pass a zoom factor of 1.0 for specific
1999 // properties that are NOT allowed to scale within a zoomed SVG document (letter/word-spacing/font-size).
2000 bool StyleResolver::useSVGZoomRules()
2001 {
2002     return m_state.element() && m_state.element()->isSVGElement();
2003 }
2004
2005 static bool createGridTrackBreadth(CSSPrimitiveValue* primitiveValue, const StyleResolver::State& state, GridLength& workingLength)
2006 {
2007     if (primitiveValue->getValueID() == CSSValueWebkitMinContent) {
2008         workingLength = Length(MinContent);
2009         return true;
2010     }
2011
2012     if (primitiveValue->getValueID() == CSSValueWebkitMaxContent) {
2013         workingLength = Length(MaxContent);
2014         return true;
2015     }
2016
2017     if (primitiveValue->isFlex()) {
2018         // Fractional unit.
2019         workingLength.setFlex(primitiveValue->getDoubleValue());
2020         return true;
2021     }
2022
2023     workingLength = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | ViewportPercentageConversion | AutoConversion>(state.style(), state.rootElementStyle(), state.style()->effectiveZoom());
2024     if (workingLength.length().isUndefined())
2025         return false;
2026
2027     if (primitiveValue->isLength())
2028         workingLength.length().setQuirk(primitiveValue->isQuirkValue());
2029
2030     return true;
2031 }
2032
2033 static bool createGridTrackSize(CSSValue* value, GridTrackSize& trackSize, const StyleResolver::State& state)
2034 {
2035     if (!value->isPrimitiveValue())
2036         return false;
2037
2038     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
2039     Pair* minMaxTrackBreadth = primitiveValue->getPairValue();
2040     if (!minMaxTrackBreadth) {
2041         GridLength workingLength;
2042         if (!createGridTrackBreadth(primitiveValue, state, workingLength))
2043             return false;
2044
2045         trackSize.setLength(workingLength);
2046         return true;
2047     }
2048
2049     GridLength minTrackBreadth;
2050     GridLength maxTrackBreadth;
2051     if (!createGridTrackBreadth(minMaxTrackBreadth->first(), state, minTrackBreadth) || !createGridTrackBreadth(minMaxTrackBreadth->second(), state, maxTrackBreadth))
2052         return false;
2053
2054     trackSize.setMinMax(minTrackBreadth, maxTrackBreadth);
2055     return true;
2056 }
2057
2058 static bool createGridTrackList(CSSValue* value, Vector<GridTrackSize>& trackSizes, NamedGridLinesMap& namedGridLines, const StyleResolver::State& state)
2059 {
2060     // Handle 'none'.
2061     if (value->isPrimitiveValue()) {
2062         CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
2063         return primitiveValue->getValueID() == CSSValueNone;
2064     }
2065
2066     if (!value->isValueList())
2067         return false;
2068
2069     size_t currentNamedGridLine = 0;
2070     for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
2071         CSSValue* currValue = i.value();
2072         if (currValue->isPrimitiveValue()) {
2073             CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(currValue);
2074             if (primitiveValue->isString()) {
2075                 NamedGridLinesMap::AddResult result = namedGridLines.add(primitiveValue->getStringValue(), Vector<size_t>());
2076                 result.iterator->value.append(currentNamedGridLine);
2077                 continue;
2078             }
2079         }
2080
2081         ++currentNamedGridLine;
2082         GridTrackSize trackSize;
2083         if (!createGridTrackSize(currValue, trackSize, state))
2084             return false;
2085
2086         trackSizes.append(trackSize);
2087     }
2088
2089     // The parser should have rejected any <track-list> without any <track-size> as
2090     // this is not conformant to the syntax.
2091     ASSERT(!trackSizes.isEmpty());
2092     return true;
2093 }
2094
2095
2096 static bool createGridPosition(CSSValue* value, GridPosition& position)
2097 {
2098     // We accept the specification's grammar:
2099     // 'auto' | [ <integer> || <string> ] | [ span && [ <integer> || string ] ] | <ident>
2100     if (value->isPrimitiveValue()) {
2101         CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
2102         // We translate <ident> to <string> during parsing as it makes handling it simpler.
2103         if (primitiveValue->isString()) {
2104             position.setNamedGridArea(primitiveValue->getStringValue());
2105             return true;
2106         }
2107
2108         ASSERT(primitiveValue->getValueID() == CSSValueAuto);
2109         return true;
2110     }
2111
2112     CSSValueList* values = toCSSValueList(value);
2113     ASSERT(values->length());
2114
2115     bool isSpanPosition = false;
2116     // The specification makes the <integer> optional, in which case it default to '1'.
2117     int gridLineNumber = 1;
2118     String gridLineName;
2119
2120     CSSValueListIterator it = values;
2121     CSSPrimitiveValue* currentValue = toCSSPrimitiveValue(it.value());
2122     if (currentValue->getValueID() == CSSValueSpan) {
2123         isSpanPosition = true;
2124         it.advance();
2125         currentValue = it.hasMore() ? toCSSPrimitiveValue(it.value()) : 0;
2126     }
2127
2128     if (currentValue && currentValue->isNumber()) {
2129         gridLineNumber = currentValue->getIntValue();
2130         it.advance();
2131         currentValue = it.hasMore() ? toCSSPrimitiveValue(it.value()) : 0;
2132     }
2133
2134     if (currentValue && currentValue->isString()) {
2135         gridLineName = currentValue->getStringValue();
2136         it.advance();
2137     }
2138
2139     ASSERT(!it.hasMore());
2140     if (isSpanPosition)
2141         position.setSpanPosition(gridLineNumber, gridLineName);
2142     else
2143         position.setExplicitPosition(gridLineNumber, gridLineName);
2144
2145     return true;
2146 }
2147
2148 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value)
2149 {
2150     ASSERT_WITH_MESSAGE(!isExpandedShorthand(id), "Shorthand property id = %d wasn't expanded at parsing time", id);
2151
2152     State& state = m_state;
2153
2154     if (CSSProperty::isDirectionAwareProperty(id)) {
2155         CSSPropertyID newId = CSSProperty::resolveDirectionAwareProperty(id, state.style()->direction(), state.style()->writingMode());
2156         ASSERT(newId != id);
2157         return applyProperty(newId, value);
2158     }
2159
2160     bool isInherit = state.parentNode() && value->isInheritedValue();
2161     bool isInitial = value->isInitialValue() || (!state.parentNode() && value->isInheritedValue());
2162
2163     ASSERT(!isInherit || !isInitial); // isInherit -> !isInitial && isInitial -> !isInherit
2164     ASSERT(!isInherit || (state.parentNode() && state.parentStyle())); // isInherit -> (state.parentNode() && state.parentStyle())
2165
2166     if (!state.applyPropertyToRegularStyle() && (!state.applyPropertyToVisitedLinkStyle() || !isValidVisitedLinkProperty(id))) {
2167         // Limit the properties that can be applied to only the ones honored by :visited.
2168         return;
2169     }
2170
2171     if (isInherit && !state.parentStyle()->hasExplicitlyInheritedProperties() && !CSSProperty::isInheritedProperty(id))
2172         state.parentStyle()->setHasExplicitlyInheritedProperties();
2173
2174     // Check lookup table for implementations and use when available.
2175     const PropertyHandler& handler = m_deprecatedStyleBuilder.propertyHandler(id);
2176     if (handler.isValid()) {
2177         if (isInherit)
2178             handler.applyInheritValue(id, this);
2179         else if (isInitial)
2180             handler.applyInitialValue(id, this);
2181         else
2182             handler.applyValue(id, this, value);
2183         return;
2184     }
2185
2186     CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? toCSSPrimitiveValue(value) : 0;
2187
2188     float zoomFactor = state.style()->effectiveZoom();
2189
2190     // What follows is a list that maps the CSS properties into their corresponding front-end
2191     // RenderStyle values.
2192     switch (id) {
2193     // lists
2194     case CSSPropertyContent:
2195         // list of string, uri, counter, attr, i
2196         {
2197             // FIXME: In CSS3, it will be possible to inherit content. In CSS2 it is not. This
2198             // note is a reminder that eventually "inherit" needs to be supported.
2199
2200             if (isInitial) {
2201                 state.style()->clearContent();
2202                 return;
2203             }
2204
2205             if (!value->isValueList())
2206                 return;
2207
2208             bool didSet = false;
2209             for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
2210                 CSSValue* item = i.value();
2211                 if (item->isImageGeneratorValue()) {
2212                     if (item->isGradientValue())
2213                         state.style()->setContent(StyleGeneratedImage::create(*toCSSGradientValue(item)->gradientWithStylesResolved(this)), didSet);
2214                     else
2215                         state.style()->setContent(StyleGeneratedImage::create(*toCSSImageGeneratorValue(item)), didSet);
2216                     didSet = true;
2217 #if ENABLE(CSS_IMAGE_SET)
2218                 } else if (item->isImageSetValue()) {
2219                     state.style()->setContent(setOrPendingFromValue(CSSPropertyContent, toCSSImageSetValue(item)), didSet);
2220                     didSet = true;
2221 #endif
2222                 }
2223
2224                 if (item->isImageValue()) {
2225                     state.style()->setContent(cachedOrPendingFromValue(CSSPropertyContent, toCSSImageValue(item)), didSet);
2226                     didSet = true;
2227                     continue;
2228                 }
2229
2230                 if (!item->isPrimitiveValue())
2231                     continue;
2232
2233                 CSSPrimitiveValue* contentValue = toCSSPrimitiveValue(item);
2234
2235                 if (contentValue->isString()) {
2236                     state.style()->setContent(contentValue->getStringValue().impl(), didSet);
2237                     didSet = true;
2238                 } else if (contentValue->isAttr()) {
2239                     // FIXME: Can a namespace be specified for an attr(foo)?
2240                     if (state.style()->styleType() == NOPSEUDO)
2241                         state.style()->setUnique();
2242                     else
2243                         state.parentStyle()->setUnique();
2244                     QualifiedName attr(nullAtom, contentValue->getStringValue().impl(), nullAtom);
2245                     const AtomicString& value = state.element()->getAttribute(attr);
2246                     state.style()->setContent(value.isNull() ? emptyAtom : value.impl(), didSet);
2247                     didSet = true;
2248                     // Register the fact that the attribute value affects the style.
2249                     m_ruleSets.features().attrsInRules.add(attr.localName().impl());
2250                 } else if (contentValue->isCounter()) {
2251                     Counter* counterValue = contentValue->getCounterValue();
2252                     EListStyleType listStyleType = NoneListStyle;
2253                     CSSValueID listStyleIdent = counterValue->listStyleIdent();
2254                     if (listStyleIdent != CSSValueNone)
2255                         listStyleType = static_cast<EListStyleType>(listStyleIdent - CSSValueDisc);
2256                     auto counter = std::make_unique<CounterContent>(counterValue->identifier(), listStyleType, counterValue->separator());
2257                     state.style()->setContent(std::move(counter), didSet);
2258                     didSet = true;
2259                 } else {
2260                     switch (contentValue->getValueID()) {
2261                     case CSSValueOpenQuote:
2262                         state.style()->setContent(OPEN_QUOTE, didSet);
2263                         didSet = true;
2264                         break;
2265                     case CSSValueCloseQuote:
2266                         state.style()->setContent(CLOSE_QUOTE, didSet);
2267                         didSet = true;
2268                         break;
2269                     case CSSValueNoOpenQuote:
2270                         state.style()->setContent(NO_OPEN_QUOTE, didSet);
2271                         didSet = true;
2272                         break;
2273                     case CSSValueNoCloseQuote:
2274                         state.style()->setContent(NO_CLOSE_QUOTE, didSet);
2275                         didSet = true;
2276                         break;
2277                     default:
2278                         // normal and none do not have any effect.
2279                         { }
2280                     }
2281                 }
2282             }
2283             if (!didSet)
2284                 state.style()->clearContent();
2285             return;
2286         }
2287     case CSSPropertyWebkitAlt:
2288         {
2289             bool didSet = false;
2290             if (primitiveValue->isString()) {
2291                 state.style()->setContentAltText(primitiveValue->getStringValue().impl());
2292                 didSet = true;
2293             } else if (primitiveValue->isAttr()) {
2294                 // FIXME: Can a namespace be specified for an attr(foo)?
2295                 if (state.style()->styleType() == NOPSEUDO)
2296                     state.style()->setUnique();
2297                 else
2298                     state.parentStyle()->setUnique();
2299                 QualifiedName attr(nullAtom, primitiveValue->getStringValue().impl(), nullAtom);
2300                 const AtomicString& value = state.element()->getAttribute(attr);
2301                 state.style()->setContentAltText(value.isNull() ? emptyAtom : value.impl());
2302                 didSet = true;
2303                 // Register the fact that the attribute value affects the style.
2304                 m_ruleSets.features().attrsInRules.add(attr.localName().impl());
2305             }
2306             if (!didSet)
2307                 state.style()->setContentAltText(emptyAtom);
2308         }
2309     case CSSPropertyQuotes:
2310         if (isInherit) {
2311             state.style()->setQuotes(state.parentStyle()->quotes());
2312             return;
2313         }
2314         if (isInitial) {
2315             state.style()->setQuotes(0);
2316             return;
2317         }
2318         if (value->isValueList()) {
2319             CSSValueList* list = toCSSValueList(value);
2320             Vector<std::pair<String, String>> quotes;
2321             for (size_t i = 0; i < list->length(); i += 2) {
2322                 CSSValue* first = list->itemWithoutBoundsCheck(i);
2323                 // item() returns null if out of bounds so this is safe.
2324                 CSSValue* second = list->item(i + 1);
2325                 if (!second)
2326                     continue;
2327                 ASSERT_WITH_SECURITY_IMPLICATION(first->isPrimitiveValue());
2328                 ASSERT_WITH_SECURITY_IMPLICATION(second->isPrimitiveValue());
2329                 String startQuote = toCSSPrimitiveValue(first)->getStringValue();
2330                 String endQuote = toCSSPrimitiveValue(second)->getStringValue();
2331                 quotes.append(std::make_pair(startQuote, endQuote));
2332             }
2333             state.style()->setQuotes(QuotesData::create(quotes));
2334             return;
2335         }
2336         if (primitiveValue) {
2337             if (primitiveValue->getValueID() == CSSValueNone)
2338                 state.style()->setQuotes(QuotesData::create(Vector<std::pair<String, String>>()));
2339         }
2340         return;
2341     // Shorthand properties.
2342     case CSSPropertyFont:
2343         if (isInherit) {
2344             FontDescription fontDescription = state.parentStyle()->fontDescription();
2345             state.style()->setLineHeight(state.parentStyle()->specifiedLineHeight());
2346             state.setLineHeightValue(0);
2347             setFontDescription(fontDescription);
2348         } else if (isInitial) {
2349             Settings* settings = documentSettings();
2350             ASSERT(settings); // If we're doing style resolution, this document should always be in a frame and thus have settings
2351             if (!settings)
2352                 return;
2353             initializeFontStyle(settings);
2354         } else if (primitiveValue) {
2355             state.style()->setLineHeight(RenderStyle::initialLineHeight());
2356             state.setLineHeightValue(0);
2357
2358             FontDescription fontDescription;
2359             RenderTheme::defaultTheme()->systemFont(primitiveValue->getValueID(), fontDescription);
2360
2361             // Double-check and see if the theme did anything. If not, don't bother updating the font.
2362             if (fontDescription.isAbsoluteSize()) {
2363                 // Make sure the rendering mode and printer font settings are updated.
2364                 Settings* settings = documentSettings();
2365                 ASSERT(settings); // If we're doing style resolution, this document should always be in a frame and thus have settings
2366                 if (!settings)
2367                     return;
2368                 fontDescription.setRenderingMode(settings->fontRenderingMode());
2369                 fontDescription.setUsePrinterFont(document().printing() || !settings->screenFontSubstitutionEnabled());
2370
2371                 // Handle the zoom factor.
2372                 fontDescription.setComputedSize(Style::computedFontSizeFromSpecifiedSize(fontDescription.specifiedSize(), fontDescription.isAbsoluteSize(), useSVGZoomRules(), state.style(), document()));
2373                 setFontDescription(fontDescription);
2374             }
2375         } else if (value->isFontValue()) {
2376             CSSFontValue* font = toCSSFontValue(value);
2377             if (!font->style || !font->variant || !font->weight
2378                 || !font->size || !font->lineHeight || !font->family)
2379                 return;
2380             applyProperty(CSSPropertyFontStyle, font->style.get());
2381             applyProperty(CSSPropertyFontVariant, font->variant.get());
2382             applyProperty(CSSPropertyFontWeight, font->weight.get());
2383             // The previous properties can dirty our font but they don't try to read the font's
2384             // properties back, which is safe. However if font-size is using the 'ex' unit, it will
2385             // need query the dirtied font's x-height to get the computed size. To be safe in this
2386             // case, let's just update the font now.
2387             updateFont();
2388             applyProperty(CSSPropertyFontSize, font->size.get());
2389
2390             state.setLineHeightValue(font->lineHeight.get());
2391
2392             applyProperty(CSSPropertyFontFamily, font->family.get());
2393         }
2394         return;
2395
2396     case CSSPropertyBackground:
2397     case CSSPropertyBackgroundPosition:
2398     case CSSPropertyBackgroundRepeat:
2399     case CSSPropertyBorder:
2400     case CSSPropertyBorderBottom:
2401     case CSSPropertyBorderColor:
2402     case CSSPropertyBorderImage:
2403     case CSSPropertyBorderLeft:
2404     case CSSPropertyBorderRadius:
2405     case CSSPropertyBorderRight:
2406     case CSSPropertyBorderSpacing:
2407     case CSSPropertyBorderStyle:
2408     case CSSPropertyBorderTop:
2409     case CSSPropertyBorderWidth:
2410     case CSSPropertyListStyle:
2411     case CSSPropertyMargin:
2412     case CSSPropertyOutline:
2413     case CSSPropertyOverflow:
2414     case CSSPropertyPadding:
2415     case CSSPropertyTransition:
2416     case CSSPropertyWebkitAnimation:
2417     case CSSPropertyWebkitBorderAfter:
2418     case CSSPropertyWebkitBorderBefore:
2419     case CSSPropertyWebkitBorderEnd:
2420     case CSSPropertyWebkitBorderStart:
2421     case CSSPropertyWebkitBorderRadius:
2422     case CSSPropertyWebkitColumns:
2423     case CSSPropertyWebkitColumnRule:
2424     case CSSPropertyWebkitFlex:
2425     case CSSPropertyWebkitFlexFlow:
2426     case CSSPropertyWebkitGridArea:
2427     case CSSPropertyWebkitGridColumn:
2428     case CSSPropertyWebkitGridRow:
2429     case CSSPropertyWebkitMarginCollapse:
2430     case CSSPropertyWebkitMarquee:
2431     case CSSPropertyWebkitMask:
2432     case CSSPropertyWebkitMaskPosition:
2433     case CSSPropertyWebkitMaskRepeat:
2434     case CSSPropertyWebkitTextEmphasis:
2435     case CSSPropertyWebkitTextStroke:
2436     case CSSPropertyWebkitTransition:
2437     case CSSPropertyWebkitTransformOrigin:
2438         ASSERT(isExpandedShorthand(id));
2439         ASSERT_NOT_REACHED();
2440         break;
2441
2442     // CSS3 Properties
2443     case CSSPropertyTextShadow:
2444     case CSSPropertyBoxShadow:
2445     case CSSPropertyWebkitBoxShadow: {
2446         if (isInherit) {
2447             if (id == CSSPropertyTextShadow)
2448                 return state.style()->setTextShadow(state.parentStyle()->textShadow() ? adoptPtr(new ShadowData(*state.parentStyle()->textShadow())) : nullptr);
2449             return state.style()->setBoxShadow(state.parentStyle()->boxShadow() ? adoptPtr(new ShadowData(*state.parentStyle()->boxShadow())) : nullptr);
2450         }
2451         if (isInitial || primitiveValue) // initial | none
2452             return id == CSSPropertyTextShadow ? state.style()->setTextShadow(nullptr) : state.style()->setBoxShadow(nullptr);
2453
2454         if (!value->isValueList())
2455             return;
2456
2457         for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
2458             CSSValue* currValue = i.value();
2459             if (!currValue->isShadowValue())
2460                 continue;
2461             CSSShadowValue* item = toCSSShadowValue(currValue);
2462             int x = item->x->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor);
2463             if (item->x->isViewportPercentageLength())
2464                 x = viewportPercentageValue(*item->x, x);
2465             int y = item->y->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor);
2466             if (item->y->isViewportPercentageLength())
2467                 y = viewportPercentageValue(*item->y, y);
2468             int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor) : 0;
2469             if (item->blur && item->blur->isViewportPercentageLength())
2470                 blur = viewportPercentageValue(*item->blur, blur);
2471             int spread = item->spread ? item->spread->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor) : 0;
2472             if (item->spread && item->spread->isViewportPercentageLength())
2473                 spread = viewportPercentageValue(*item->spread, spread);
2474             ShadowStyle shadowStyle = item->style && item->style->getValueID() == CSSValueInset ? Inset : Normal;
2475             Color color;
2476             if (item->color)
2477                 color = colorFromPrimitiveValue(item->color.get());
2478             else if (state.style())
2479                 color = state.style()->color();
2480
2481             OwnPtr<ShadowData> shadowData = adoptPtr(new ShadowData(IntPoint(x, y), blur, spread, shadowStyle, id == CSSPropertyWebkitBoxShadow, color.isValid() ? color : Color::transparent));
2482             if (id == CSSPropertyTextShadow)
2483                 state.style()->setTextShadow(shadowData.release(), i.index()); // add to the list if this is not the first entry
2484             else
2485                 state.style()->setBoxShadow(shadowData.release(), i.index()); // add to the list if this is not the first entry
2486         }
2487         return;
2488     }
2489     case CSSPropertyWebkitBoxReflect: {
2490         HANDLE_INHERIT_AND_INITIAL(boxReflect, BoxReflect)
2491         if (primitiveValue) {
2492             state.style()->setBoxReflect(RenderStyle::initialBoxReflect());
2493             return;
2494         }
2495
2496         if (!value->isReflectValue())
2497             return;
2498
2499         CSSReflectValue* reflectValue = toCSSReflectValue(value);
2500         RefPtr<StyleReflection> reflection = StyleReflection::create();
2501         reflection->setDirection(*reflectValue->direction());
2502         if (reflectValue->offset())
2503             reflection->setOffset(reflectValue->offset()->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(state.style(), state.rootElementStyle(), zoomFactor));
2504         NinePieceImage mask;
2505         mask.setMaskDefaults();
2506         m_styleMap.mapNinePieceImage(id, reflectValue->mask(), mask);
2507         reflection->setMask(mask);
2508
2509         state.style()->setBoxReflect(reflection.release());
2510         return;
2511     }
2512     case CSSPropertySrc: // Only used in @font-face rules.
2513         return;
2514     case CSSPropertyUnicodeRange: // Only used in @font-face rules.
2515         return;
2516     case CSSPropertyWebkitLocale: {
2517         HANDLE_INHERIT_AND_INITIAL(locale, Locale);
2518         if (!primitiveValue)
2519             return;
2520         if (primitiveValue->getValueID() == CSSValueAuto)
2521             state.style()->setLocale(nullAtom);
2522         else
2523             state.style()->setLocale(primitiveValue->getStringValue());
2524         FontDescription fontDescription = state.style()->fontDescription();
2525         fontDescription.setScript(localeToScriptCodeForFontSelection(state.style()->locale()));
2526         setFontDescription(fontDescription);
2527         return;
2528     }
2529 #if ENABLE(IOS_TEXT_AUTOSIZING)
2530     case CSSPropertyWebkitTextSizeAdjust: {
2531         HANDLE_INHERIT_AND_INITIAL(textSizeAdjust, TextSizeAdjust)
2532         if (!primitiveValue)
2533             return;
2534
2535         if (primitiveValue->getValueID() == CSSValueAuto)
2536             state.style()->setTextSizeAdjust(TextSizeAdjustment(AutoTextSizeAdjustment));
2537         else if (primitiveValue->getValueID() == CSSValueNone)
2538             state.style()->setTextSizeAdjust(TextSizeAdjustment(NoTextSizeAdjustment));
2539         else
2540             state.style()->setTextSizeAdjust(TextSizeAdjustment(primitiveValue->getFloatValue()));
2541
2542         state.setFontDirty(true);
2543         return;
2544     }
2545 #endif
2546 #if ENABLE(DASHBOARD_SUPPORT)
2547     case CSSPropertyWebkitDashboardRegion:
2548     {
2549         HANDLE_INHERIT_AND_INITIAL(dashboardRegions, DashboardRegions)
2550         if (!primitiveValue)
2551             return;
2552
2553         if (primitiveValue->getValueID() == CSSValueNone) {
2554             state.style()->setDashboardRegions(RenderStyle::noneDashboardRegions());
2555             return;
2556         }
2557
2558         DashboardRegion* region = primitiveValue->getDashboardRegionValue();
2559         if (!region)
2560             return;
2561
2562         DashboardRegion* first = region;
2563         while (region) {
2564             Length top = convertToIntLength(region->top(), state.style(), state.rootElementStyle());
2565             Length right = convertToIntLength(region->right(), state.style(), state.rootElementStyle());
2566             Length bottom = convertToIntLength(region->bottom(), state.style(), state.rootElementStyle());
2567             Length left = convertToIntLength(region->left(), state.style(), state.rootElementStyle());
2568
2569             if (top.isUndefined())
2570                 top = Length();
2571             if (right.isUndefined())
2572                 right = Length();
2573             if (bottom.isUndefined())
2574                 bottom = Length();
2575             if (left.isUndefined())
2576                 left = Length();
2577
2578             if (region->m_isCircle)
2579                 state.style()->setDashboardRegion(StyleDashboardRegion::Circle, region->m_label, top, right, bottom, left, region == first ? false : true);
2580             else if (region->m_isRectangle)
2581                 state.style()->setDashboardRegion(StyleDashboardRegion::Rectangle, region->m_label, top, right, bottom, left, region == first ? false : true);
2582             region = region->m_next.get();
2583         }
2584
2585         state.document().setHasAnnotatedRegions(true);
2586
2587         return;
2588     }
2589 #endif
2590 #if ENABLE(DRAGGABLE_REGION)
2591     case CSSPropertyWebkitAppRegion: {
2592         if (!primitiveValue || !primitiveValue->getValueID())
2593             return;
2594         state.style()->setDraggableRegionMode(primitiveValue->getValueID() == CSSValueDrag ? DraggableRegionDrag : DraggableRegionNoDrag);
2595         state.document().setHasAnnotatedRegions(true);
2596         return;
2597     }
2598 #endif
2599     case CSSPropertyWebkitTextStrokeWidth: {
2600         HANDLE_INHERIT_AND_INITIAL(textStrokeWidth, TextStrokeWidth)
2601         float width = 0;
2602         switch (primitiveValue->getValueID()) {
2603         case CSSValueThin:
2604         case CSSValueMedium:
2605         case CSSValueThick: {
2606             double result = 1.0 / 48;
2607             if (primitiveValue->getValueID() == CSSValueMedium)
2608                 result *= 3;
2609             else if (primitiveValue->getValueID() == CSSValueThick)
2610                 result *= 5;
2611             Ref<CSSPrimitiveValue> value(CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS));
2612             width = value.get().computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
2613             break;
2614         }
2615         default:
2616             width = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
2617             break;
2618         }
2619         state.style()->setTextStrokeWidth(width);
2620         return;
2621     }
2622     case CSSPropertyWebkitTransform: {
2623         HANDLE_INHERIT_AND_INITIAL(transform, Transform);
2624         TransformOperations operations;
2625         transformsForValue(state.style(), state.rootElementStyle(), value, operations);
2626         state.style()->setTransform(operations);
2627         return;
2628     }
2629     case CSSPropertyWebkitPerspective: {
2630         HANDLE_INHERIT_AND_INITIAL(perspective, Perspective)
2631
2632         if (!primitiveValue)
2633             return;
2634
2635         if (primitiveValue->getValueID() == CSSValueNone) {
2636             state.style()->setPerspective(0);
2637             return;
2638         }
2639
2640         float perspectiveValue;
2641         if (primitiveValue->isLength())
2642             perspectiveValue = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
2643         else if (primitiveValue->isNumber()) {
2644             // For backward compatibility, treat valueless numbers as px.
2645             Ref<CSSPrimitiveValue> value(CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX));
2646             perspectiveValue = value.get().computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
2647         } else
2648             return;
2649
2650         if (perspectiveValue >= 0.0f)
2651             state.style()->setPerspective(perspectiveValue);
2652         return;
2653     }
2654 #if PLATFORM(IOS)
2655     case CSSPropertyWebkitTouchCallout: {
2656         HANDLE_INHERIT_AND_INITIAL(touchCalloutEnabled, TouchCalloutEnabled);
2657         if (!primitiveValue)
2658             break;
2659
2660         state.style()->setTouchCalloutEnabled(primitiveValue->getStringValue().lower() != "none");
2661         return;
2662     }
2663 #endif
2664 #if ENABLE(TOUCH_EVENTS)
2665     case CSSPropertyWebkitTapHighlightColor: {
2666         HANDLE_INHERIT_AND_INITIAL(tapHighlightColor, TapHighlightColor);
2667         if (!primitiveValue)
2668             break;
2669
2670         Color col = colorFromPrimitiveValue(primitiveValue);
2671         state.style()->setTapHighlightColor(col);
2672         return;
2673     }
2674 #endif
2675 #if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
2676     case CSSPropertyWebkitOverflowScrolling: {
2677         HANDLE_INHERIT_AND_INITIAL(useTouchOverflowScrolling, UseTouchOverflowScrolling);
2678         if (!primitiveValue)
2679             break;
2680         state.style()->setUseTouchOverflowScrolling(primitiveValue->getValueID() == CSSValueTouch);
2681         return;
2682     }
2683 #endif
2684     case CSSPropertyInvalid:
2685         return;
2686     case CSSPropertyFontStretch:
2687     case CSSPropertyPage:
2688     case CSSPropertyTextLineThrough:
2689     case CSSPropertyTextLineThroughColor:
2690     case CSSPropertyTextLineThroughMode:
2691     case CSSPropertyTextLineThroughStyle:
2692     case CSSPropertyTextLineThroughWidth:
2693     case CSSPropertyTextOverline:
2694     case CSSPropertyTextOverlineColor:
2695     case CSSPropertyTextOverlineMode:
2696     case CSSPropertyTextOverlineStyle:
2697     case CSSPropertyTextOverlineWidth:
2698     case CSSPropertyTextUnderline:
2699     case CSSPropertyTextUnderlineColor:
2700     case CSSPropertyTextUnderlineMode:
2701     case CSSPropertyTextUnderlineStyle:
2702     case CSSPropertyTextUnderlineWidth:
2703     case CSSPropertyWebkitFontSizeDelta:
2704     case CSSPropertyWebkitTextDecorationsInEffect:
2705         return;
2706
2707     // CSS Text Layout Module Level 3: Vertical writing support
2708     case CSSPropertyWebkitWritingMode: {
2709         HANDLE_INHERIT_AND_INITIAL(writingMode, WritingMode);
2710         
2711         if (primitiveValue)
2712             setWritingMode(*primitiveValue);
2713
2714         // FIXME: It is not ok to modify document state while applying style.
2715         if (state.element() && state.element() == state.document().documentElement())
2716             state.document().setWritingModeSetOnDocumentElement(true);
2717         return;
2718     }
2719
2720     case CSSPropertyWebkitTextOrientation: {
2721         HANDLE_INHERIT_AND_INITIAL(textOrientation, TextOrientation);
2722
2723         if (primitiveValue)
2724             setTextOrientation(*primitiveValue);
2725
2726         return;
2727     }
2728
2729     case CSSPropertyWebkitLineBoxContain: {
2730         HANDLE_INHERIT_AND_INITIAL(lineBoxContain, LineBoxContain)
2731         if (primitiveValue && primitiveValue->getValueID() == CSSValueNone) {
2732             state.style()->setLineBoxContain(LineBoxContainNone);
2733             return;
2734         }
2735
2736         if (!value->isLineBoxContainValue())
2737             return;
2738
2739         state.style()->setLineBoxContain(toCSSLineBoxContainValue(value)->value());
2740         return;
2741     }
2742
2743     // CSS Fonts Module Level 3
2744     case CSSPropertyWebkitFontFeatureSettings: {
2745         if (primitiveValue && primitiveValue->getValueID() == CSSValueNormal) {
2746             setFontDescription(state.style()->fontDescription().makeNormalFeatureSettings());
2747             return;
2748         }
2749
2750         if (!value->isValueList())
2751             return;
2752
2753         FontDescription fontDescription = state.style()->fontDescription();
2754         CSSValueList* list = toCSSValueList(value);
2755         RefPtr<FontFeatureSettings> settings = FontFeatureSettings::create();
2756         int len = list->length();
2757         for (int i = 0; i < len; ++i) {
2758             CSSValue* item = list->itemWithoutBoundsCheck(i);
2759             if (!item->isFontFeatureValue())
2760                 continue;
2761             CSSFontFeatureValue* feature = toCSSFontFeatureValue(item);
2762             settings->append(FontFeature(feature->tag(), feature->value()));
2763         }
2764         fontDescription.setFeatureSettings(settings.release());
2765         setFontDescription(fontDescription);
2766         return;
2767     }
2768
2769 #if ENABLE(CSS_FILTERS)
2770     case CSSPropertyWebkitFilter: {
2771         HANDLE_INHERIT_AND_INITIAL(filter, Filter);
2772         FilterOperations operations;
2773         if (createFilterOperations(value, operations))
2774             state.style()->setFilter(operations);
2775         return;
2776     }
2777 #endif
2778     case CSSPropertyWebkitGridAutoColumns: {
2779         HANDLE_INHERIT_AND_INITIAL(gridAutoColumns, GridAutoColumns);
2780         GridTrackSize trackSize;
2781         if (!createGridTrackSize(value, trackSize, state))
2782             return;
2783         state.style()->setGridAutoColumns(trackSize);
2784         return;
2785     }
2786     case CSSPropertyWebkitGridAutoRows: {
2787         HANDLE_INHERIT_AND_INITIAL(gridAutoRows, GridAutoRows);
2788         GridTrackSize trackSize;
2789         if (!createGridTrackSize(value, trackSize, state))
2790             return;
2791         state.style()->setGridAutoRows(trackSize);
2792         return;
2793     }
2794     case CSSPropertyWebkitGridDefinitionColumns: {
2795         if (isInherit) {
2796             m_state.style()->setGridColumns(m_state.parentStyle()->gridColumns());
2797             m_state.style()->setNamedGridColumnLines(m_state.parentStyle()->namedGridColumnLines());
2798             return;
2799         }
2800         if (isInitial) {
2801             m_state.style()->setGridColumns(RenderStyle::initialGridColumns());
2802             m_state.style()->setNamedGridColumnLines(RenderStyle::initialNamedGridColumnLines());
2803             return;
2804         }
2805         Vector<GridTrackSize> trackSizes;
2806         NamedGridLinesMap namedGridLines;
2807         if (!createGridTrackList(value, trackSizes, namedGridLines, state))
2808             return;
2809         state.style()->setGridColumns(trackSizes);
2810         state.style()->setNamedGridColumnLines(namedGridLines);
2811         return;
2812     }
2813     case CSSPropertyWebkitGridDefinitionRows: {
2814         if (isInherit) {
2815             m_state.style()->setGridRows(m_state.parentStyle()->gridRows());
2816             m_state.style()->setNamedGridRowLines(m_state.parentStyle()->namedGridRowLines());
2817             return;
2818         }
2819         if (isInitial) {
2820             m_state.style()->setGridRows(RenderStyle::initialGridRows());
2821             m_state.style()->setNamedGridRowLines(RenderStyle::initialNamedGridRowLines());
2822             return;
2823         }
2824         Vector<GridTrackSize> trackSizes;
2825         NamedGridLinesMap namedGridLines;
2826         if (!createGridTrackList(value, trackSizes, namedGridLines, state))
2827             return;
2828         state.style()->setGridRows(trackSizes);
2829         state.style()->setNamedGridRowLines(namedGridLines);
2830         return;
2831     }
2832
2833     case CSSPropertyWebkitGridColumnStart: {
2834         HANDLE_INHERIT_AND_INITIAL(gridItemColumnStart, GridItemColumnStart);
2835         GridPosition columnStartPosition;
2836         if (!createGridPosition(value, columnStartPosition))
2837             return;
2838         state.style()->setGridItemColumnStart(columnStartPosition);
2839         return;
2840     }
2841     case CSSPropertyWebkitGridColumnEnd: {
2842         HANDLE_INHERIT_AND_INITIAL(gridItemColumnEnd, GridItemColumnEnd);
2843         GridPosition columnEndPosition;
2844         if (!createGridPosition(value, columnEndPosition))
2845             return;
2846         state.style()->setGridItemColumnEnd(columnEndPosition);
2847         return;
2848     }
2849
2850     case CSSPropertyWebkitGridRowStart: {
2851         HANDLE_INHERIT_AND_INITIAL(gridItemRowStart, GridItemRowStart);
2852         GridPosition rowStartPosition;
2853         if (!createGridPosition(value, rowStartPosition))
2854             return;
2855         state.style()->setGridItemRowStart(rowStartPosition);
2856         return;
2857     }
2858     case CSSPropertyWebkitGridRowEnd: {
2859         HANDLE_INHERIT_AND_INITIAL(gridItemRowEnd, GridItemRowEnd);
2860         GridPosition rowEndPosition;
2861         if (!createGridPosition(value, rowEndPosition))
2862             return;
2863         state.style()->setGridItemRowEnd(rowEndPosition);
2864         return;
2865     }
2866     case CSSPropertyWebkitGridTemplate: {
2867         if (isInherit) {
2868             state.style()->setNamedGridArea(state.parentStyle()->namedGridArea());
2869             state.style()->setNamedGridAreaRowCount(state.parentStyle()->namedGridAreaRowCount());
2870             state.style()->setNamedGridAreaColumnCount(state.parentStyle()->namedGridAreaColumnCount());
2871             return;
2872         }
2873         if (isInitial) {
2874             state.style()->setNamedGridArea(RenderStyle::initialNamedGridArea());
2875             state.style()->setNamedGridAreaRowCount(RenderStyle::initialNamedGridAreaCount());
2876             state.style()->setNamedGridAreaColumnCount(RenderStyle::initialNamedGridAreaCount());
2877             return;
2878         }
2879
2880         if (value->isPrimitiveValue()) {
2881             ASSERT(toCSSPrimitiveValue(value)->getValueID() == CSSValueNone);
2882             return;
2883         }
2884
2885         CSSGridTemplateValue* gridTemplateValue = toCSSGridTemplateValue(value);
2886         state.style()->setNamedGridArea(gridTemplateValue->gridAreaMap());
2887         state.style()->setNamedGridAreaRowCount(gridTemplateValue->rowCount());
2888         state.style()->setNamedGridAreaColumnCount(gridTemplateValue->columnCount());
2889         return;
2890     }
2891
2892     // These properties are aliased and DeprecatedStyleBuilder already applied the property on the prefixed version.
2893     case CSSPropertyTransitionDelay:
2894     case CSSPropertyTransitionDuration:
2895     case CSSPropertyTransitionProperty:
2896     case CSSPropertyTransitionTimingFunction:
2897         return;
2898     // These properties are implemented in the DeprecatedStyleBuilder lookup table.
2899     case CSSPropertyBackgroundAttachment:
2900     case CSSPropertyBackgroundClip:
2901     case CSSPropertyBackgroundColor:
2902     case CSSPropertyBackgroundImage:
2903     case CSSPropertyBackgroundOrigin:
2904     case CSSPropertyBackgroundPositionX:
2905     case CSSPropertyBackgroundPositionY:
2906     case CSSPropertyBackgroundRepeatX:
2907     case CSSPropertyBackgroundRepeatY:
2908     case CSSPropertyBackgroundSize:
2909     case CSSPropertyBorderBottomColor:
2910     case CSSPropertyBorderBottomLeftRadius:
2911     case CSSPropertyBorderBottomRightRadius:
2912     case CSSPropertyBorderBottomStyle:
2913     case CSSPropertyBorderBottomWidth:
2914     case CSSPropertyBorderCollapse:
2915     case CSSPropertyBorderImageOutset:
2916     case CSSPropertyBorderImageRepeat:
2917     case CSSPropertyBorderImageSlice:
2918     case CSSPropertyBorderImageSource:
2919     case CSSPropertyBorderImageWidth:
2920     case CSSPropertyBorderLeftColor:
2921     case CSSPropertyBorderLeftStyle:
2922     case CSSPropertyBorderLeftWidth:
2923     case CSSPropertyBorderRightColor:
2924     case CSSPropertyBorderRightStyle:
2925     case CSSPropertyBorderRightWidth:
2926     case CSSPropertyBorderTopColor:
2927     case CSSPropertyBorderTopLeftRadius:
2928     case CSSPropertyBorderTopRightRadius:
2929     case CSSPropertyBorderTopStyle:
2930     case CSSPropertyBorderTopWidth:
2931     case CSSPropertyBottom:
2932     case CSSPropertyBoxSizing:
2933     case CSSPropertyCaptionSide:
2934     case CSSPropertyClear:
2935     case CSSPropertyClip:
2936     case CSSPropertyColor:
2937     case CSSPropertyCounterIncrement:
2938     case CSSPropertyCounterReset:
2939     case CSSPropertyCursor:
2940     case CSSPropertyDirection:
2941     case CSSPropertyDisplay:
2942     case CSSPropertyEmptyCells:
2943     case CSSPropertyFloat:
2944     case CSSPropertyFontSize:
2945     case CSSPropertyFontStyle:
2946     case CSSPropertyFontVariant:
2947     case CSSPropertyFontWeight:
2948     case CSSPropertyHeight:
2949 #if ENABLE(CSS_IMAGE_ORIENTATION)
2950     case CSSPropertyImageOrientation:
2951 #endif
2952     case CSSPropertyImageRendering:
2953 #if ENABLE(CSS_IMAGE_RESOLUTION)
2954     case CSSPropertyImageResolution:
2955 #endif
2956     case CSSPropertyLeft:
2957     case CSSPropertyLetterSpacing:
2958     case CSSPropertyLineHeight:
2959     case CSSPropertyListStyleImage:
2960     case CSSPropertyListStylePosition:
2961     case CSSPropertyListStyleType:
2962     case CSSPropertyMarginBottom:
2963     case CSSPropertyMarginLeft:
2964     case CSSPropertyMarginRight:
2965     case CSSPropertyMarginTop:
2966     case CSSPropertyMaxHeight:
2967     case CSSPropertyMaxWidth:
2968     case CSSPropertyMinHeight:
2969     case CSSPropertyMinWidth:
2970     case CSSPropertyObjectFit:
2971     case CSSPropertyOpacity:
2972     case CSSPropertyOrphans:
2973     case CSSPropertyOutlineColor:
2974     case CSSPropertyOutlineOffset:
2975     case CSSPropertyOutlineStyle:
2976     case CSSPropertyOutlineWidth:
2977     case CSSPropertyOverflowWrap:
2978     case CSSPropertyOverflowX:
2979     case CSSPropertyOverflowY:
2980     case CSSPropertyPaddingBottom:
2981     case CSSPropertyPaddingLeft:
2982     case CSSPropertyPaddingRight:
2983     case CSSPropertyPaddingTop:
2984     case CSSPropertyPageBreakAfter:
2985     case CSSPropertyPageBreakBefore:
2986     case CSSPropertyPageBreakInside:
2987     case CSSPropertyPointerEvents:
2988     case CSSPropertyPosition:
2989     case CSSPropertyResize:
2990     case CSSPropertyRight:
2991     case CSSPropertySize:
2992     case CSSPropertySpeak:
2993     case CSSPropertyTabSize:
2994     case CSSPropertyTableLayout:
2995     case CSSPropertyTextAlign:
2996     case CSSPropertyTextDecoration:
2997     case CSSPropertyTextIndent:
2998     case CSSPropertyTextOverflow:
2999     case CSSPropertyTextRendering:
3000     case CSSPropertyTextTransform:
3001     case CSSPropertyTop:
3002     case CSSPropertyUnicodeBidi:
3003     case CSSPropertyVerticalAlign:
3004     case CSSPropertyVisibility:
3005     case CSSPropertyWebkitAnimationDelay:
3006     case CSSPropertyWebkitAnimationDirection:
3007     case CSSPropertyWebkitAnimationDuration:
3008     case CSSPropertyWebkitAnimationFillMode:
3009     case CSSPropertyWebkitAnimationIterationCount:
3010     case CSSPropertyWebkitAnimationName:
3011     case CSSPropertyWebkitAnimationPlayState:
3012     case CSSPropertyWebkitAnimationTimingFunction:
3013     case CSSPropertyWebkitAppearance:
3014     case CSSPropertyWebkitAspectRatio:
3015     case CSSPropertyWebkitBackfaceVisibility:
3016     case CSSPropertyWebkitBackgroundClip:
3017     case CSSPropertyWebkitBackgroundComposite:
3018     case CSSPropertyWebkitBackgroundOrigin:
3019     case CSSPropertyWebkitBackgroundSize:
3020     case CSSPropertyWebkitBorderFit:
3021     case CSSPropertyWebkitBorderHorizontalSpacing:
3022     case CSSPropertyWebkitBorderImage:
3023     case CSSPropertyWebkitBorderVerticalSpacing:
3024     case CSSPropertyWebkitBoxAlign:
3025 #if ENABLE(CSS_BOX_DECORATION_BREAK)
3026     case CSSPropertyWebkitBoxDecorationBreak:
3027 #endif
3028     case CSSPropertyWebkitBoxDirection:
3029     case CSSPropertyWebkitBoxFlex:
3030     case CSSPropertyWebkitBoxFlexGroup:
3031     case CSSPropertyWebkitBoxLines:
3032     case CSSPropertyWebkitBoxOrdinalGroup:
3033     case CSSPropertyWebkitBoxOrient:
3034     case CSSPropertyWebkitBoxPack:
3035     case CSSPropertyWebkitColorCorrection:
3036     case CSSPropertyWebkitColumnAxis:
3037     case CSSPropertyWebkitColumnBreakAfter:
3038     case CSSPropertyWebkitColumnBreakBefore:
3039     case CSSPropertyWebkitColumnBreakInside:
3040     case CSSPropertyWebkitColumnCount:
3041     case CSSPropertyWebkitColumnGap:
3042     case CSSPropertyWebkitColumnProgression:
3043     case CSSPropertyWebkitColumnRuleColor:
3044     case CSSPropertyWebkitColumnRuleStyle:
3045     case CSSPropertyWebkitColumnRuleWidth:
3046     case CSSPropertyWebkitColumnSpan:
3047     case CSSPropertyWebkitColumnWidth:
3048 #if ENABLE(CURSOR_VISIBILITY)
3049     case CSSPropertyWebkitCursorVisibility:
3050 #endif
3051     case CSSPropertyWebkitAlignContent:
3052     case CSSPropertyWebkitAlignItems:
3053     case CSSPropertyWebkitAlignSelf:
3054     case CSSPropertyWebkitFlexBasis:
3055     case CSSPropertyWebkitFlexDirection:
3056     case CSSPropertyWebkitFlexGrow:
3057     case CSSPropertyWebkitFlexShrink:
3058     case CSSPropertyWebkitFlexWrap:
3059     case CSSPropertyWebkitJustifyContent:
3060     case CSSPropertyWebkitOrder:
3061 #if ENABLE(CSS_REGIONS)
3062     case CSSPropertyWebkitFlowFrom:
3063     case CSSPropertyWebkitFlowInto:
3064 #endif
3065     case CSSPropertyWebkitFontKerning:
3066     case CSSPropertyWebkitFontSmoothing:
3067     case CSSPropertyWebkitFontVariantLigatures:
3068     case CSSPropertyWebkitHighlight:
3069     case CSSPropertyWebkitHyphenateCharacter:
3070     case CSSPropertyWebkitHyphenateLimitAfter:
3071     case CSSPropertyWebkitHyphenateLimitBefore:
3072     case CSSPropertyWebkitHyphenateLimitLines:
3073     case CSSPropertyWebkitHyphens:
3074     case CSSPropertyWebkitLineAlign:
3075     case CSSPropertyWebkitLineBreak:
3076     case CSSPropertyWebkitLineClamp:
3077     case CSSPropertyWebkitLineGrid:
3078     case CSSPropertyWebkitLineSnap:
3079     case CSSPropertyWebkitMarqueeDirection:
3080     case CSSPropertyWebkitMarqueeIncrement:
3081     case CSSPropertyWebkitMarqueeRepetition:
3082     case CSSPropertyWebkitMarqueeSpeed:
3083     case CSSPropertyWebkitMarqueeStyle:
3084     case CSSPropertyWebkitMaskBoxImage:
3085     case CSSPropertyWebkitMaskBoxImageOutset:
3086     case CSSPropertyWebkitMaskBoxImageRepeat:
3087     case CSSPropertyWebkitMaskBoxImageSlice:
3088     case CSSPropertyWebkitMaskBoxImageSource:
3089     case CSSPropertyWebkitMaskBoxImageWidth:
3090     case CSSPropertyWebkitMaskClip:
3091     case CSSPropertyWebkitMaskComposite:
3092     case CSSPropertyWebkitMaskImage:
3093     case CSSPropertyWebkitMaskOrigin:
3094     case CSSPropertyWebkitMaskPositionX:
3095     case CSSPropertyWebkitMaskPositionY:
3096     case CSSPropertyWebkitMaskRepeatX:
3097     case CSSPropertyWebkitMaskRepeatY:
3098     case CSSPropertyWebkitMaskSize:
3099     case CSSPropertyWebkitMaskSourceType:
3100     case CSSPropertyWebkitNbspMode:
3101     case CSSPropertyWebkitPerspectiveOrigin:
3102     case CSSPropertyWebkitPerspectiveOriginX:
3103     case CSSPropertyWebkitPerspectiveOriginY:
3104     case CSSPropertyWebkitPrintColorAdjust:
3105 #if ENABLE(CSS_REGIONS)
3106     case CSSPropertyWebkitRegionBreakAfter:
3107     case CSSPropertyWebkitRegionBreakBefore:
3108     case CSSPropertyWebkitRegionBreakInside:
3109     case CSSPropertyWebkitRegionFragment:
3110 #endif
3111     case CSSPropertyWebkitRtlOrdering:
3112     case CSSPropertyWebkitRubyPosition:
3113     case CSSPropertyWebkitTextCombine:
3114 #if ENABLE(CSS3_TEXT)
3115     case CSSPropertyWebkitTextAlignLast:
3116     case CSSPropertyWebkitTextJustify:
3117 #endif // CSS3_TEXT
3118 #if ENABLE(CSS3_TEXT_DECORATION)
3119     case CSSPropertyWebkitTextDecorationLine:
3120     case CSSPropertyWebkitTextDecorationStyle:
3121     case CSSPropertyWebkitTextDecorationColor:
3122     case CSSPropertyWebkitTextDecorationSkip:
3123     case CSSPropertyWebkitTextUnderlinePosition:
3124 #endif
3125     case CSSPropertyWebkitTextEmphasisColor:
3126     case CSSPropertyWebkitTextEmphasisPosition:
3127     case CSSPropertyWebkitTextEmphasisStyle:
3128     case CSSPropertyWebkitTextFillColor:
3129     case CSSPropertyWebkitTextSecurity:
3130     case CSSPropertyWebkitTextStrokeColor:
3131     case CSSPropertyWebkitTransformOriginX:
3132     case CSSPropertyWebkitTransformOriginY:
3133     case CSSPropertyWebkitTransformOriginZ:
3134     case CSSPropertyWebkitTransformStyle:
3135     case CSSPropertyWebkitTransitionDelay:
3136     case CSSPropertyWebkitTransitionDuration:
3137     case CSSPropertyWebkitTransitionProperty:
3138     case CSSPropertyWebkitTransitionTimingFunction:
3139     case CSSPropertyWebkitUserDrag:
3140     case CSSPropertyWebkitUserModify:
3141     case CSSPropertyWebkitUserSelect:
3142     case CSSPropertyWebkitClipPath:
3143 #if ENABLE(CSS_SHAPES)
3144     case CSSPropertyWebkitShapeMargin:
3145     case CSSPropertyWebkitShapePadding:
3146     case CSSPropertyWebkitShapeImageThreshold:
3147     case CSSPropertyWebkitShapeInside:
3148     case CSSPropertyWebkitShapeOutside:
3149 #endif
3150 #if ENABLE(CSS_EXCLUSIONS)
3151     case CSSPropertyWebkitWrapFlow:
3152     case CSSPropertyWebkitWrapThrough:
3153 #endif
3154 #if ENABLE(CSS_SHADERS)
3155     case CSSPropertyMix:
3156     case CSSPropertyParameters:
3157 #endif
3158     case CSSPropertyWhiteSpace:
3159     case CSSPropertyWidows:
3160     case CSSPropertyWidth:
3161     case CSSPropertyWordBreak:
3162     case CSSPropertyWordSpacing:
3163     case CSSPropertyWordWrap:
3164     case CSSPropertyZIndex:
3165     case CSSPropertyZoom:
3166 #if ENABLE(CSS_DEVICE_ADAPTATION)
3167     case CSSPropertyMaxZoom:
3168     case CSSPropertyMinZoom:
3169     case CSSPropertyOrientation:
3170     case CSSPropertyUserZoom:
3171 #endif
3172         ASSERT_NOT_REACHED();
3173         return;
3174     default:
3175 #if ENABLE(SVG)
3176         // Try the SVG properties
3177         applySVGProperty(id, value);
3178 #endif
3179         return;
3180     }
3181 }
3182
3183 PassRefPtr<StyleImage> StyleResolver::styleImage(CSSPropertyID property, CSSValue* value)
3184 {
3185     if (value->isImageValue())
3186         return cachedOrPendingFromValue(property, toCSSImageValue(value));
3187
3188     if (value->isImageGeneratorValue()) {
3189         if (value->isGradientValue())
3190             return generatedOrPendingFromValue(property, *toCSSGradientValue(value)->gradientWithStylesResolved(this));
3191         return generatedOrPendingFromValue(property, toCSSImageGeneratorValue(*value));
3192     }
3193
3194 #if ENABLE(CSS_IMAGE_SET)
3195     if (value->isImageSetValue())
3196         return setOrPendingFromValue(property, toCSSImageSetValue(value));
3197 #endif
3198
3199     if (value->isCursorImageValue())
3200         return cursorOrPendingFromValue(property, toCSSCursorImageValue(value));
3201
3202     return 0;
3203 }
3204
3205 PassRefPtr<StyleImage> StyleResolver::cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue* value)
3206 {
3207     RefPtr<StyleImage> image = value->cachedOrPendingImage();
3208     if (image && image->isPendingImage())
3209         m_state.pendingImageProperties().set(property, value);
3210     return image.release();
3211 }
3212
3213 PassRefPtr<StyleImage> StyleResolver::generatedOrPendingFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
3214 {
3215 #if ENABLE(CSS_FILTERS)
3216     if (value.isFilterImageValue()) {
3217         // FilterImage needs to calculate FilterOperations.
3218         toCSSFilterImageValue(value).createFilterOperations(this);
3219     }
3220 #endif
3221     if (value.isPending()) {
3222         m_state.pendingImageProperties().set(property, &value);
3223         return StylePendingImage::create(&value);
3224     }
3225     return StyleGeneratedImage::create(value);
3226 }
3227
3228 #if ENABLE(CSS_IMAGE_SET)
3229 PassRefPtr<StyleImage> StyleResolver::setOrPendingFromValue(CSSPropertyID property, CSSImageSetValue* value)
3230 {
3231     RefPtr<StyleImage> image = value->cachedOrPendingImageSet(document());
3232     if (image && image->isPendingImage())
3233         m_state.pendingImageProperties().set(property, value);
3234     return image.release();
3235 }
3236 #endif
3237
3238 PassRefPtr<StyleImage> StyleResolver::cursorOrPendingFromValue(CSSPropertyID property, CSSCursorImageValue* value)
3239 {
3240     RefPtr<StyleImage> image = value->cachedOrPendingImage(document());
3241     if (image && image->isPendingImage())
3242         m_state.pendingImageProperties().set(property, value);
3243     return image.release();
3244 }
3245
3246 #if ENABLE(IOS_TEXT_AUTOSIZING)
3247 void StyleResolver::checkForTextSizeAdjust(RenderStyle* style)
3248 {
3249     if (style->textSizeAdjust().isAuto())
3250         return;
3251
3252     FontDescription newFontDescription(style->fontDescription());
3253     if (!style->textSizeAdjust().isNone())
3254         newFontDescription.setComputedSize(newFontDescription.specifiedSize() * style->textSizeAdjust().multiplier());
3255     else
3256         newFontDescription.setComputedSize(newFontDescription.specifiedSize());
3257     style->setFontDescription(newFontDescription);
3258 }
3259 #endif
3260
3261 void StyleResolver::checkForZoomChange(RenderStyle* style, RenderStyle* parentStyle)
3262 {
3263     if (style->effectiveZoom() == parentStyle->effectiveZoom())
3264         return;
3265
3266     const FontDescription& childFont = style->fontDescription();
3267     FontDescription newFontDescription(childFont);
3268     setFontSize(newFontDescription, childFont.specifiedSize());
3269     style->setFontDescription(newFontDescription);
3270 }
3271
3272 void StyleResolver::checkForGenericFamilyChange(RenderStyle* style, RenderStyle* parentStyle)
3273 {
3274     const FontDescription& childFont = style->fontDescription();
3275
3276     if (childFont.isAbsoluteSize() || !parentStyle)
3277         return;
3278
3279     const FontDescription& parentFont = parentStyle->fontDescription();
3280     if (childFont.useFixedDefaultSize() == parentFont.useFixedDefaultSize())
3281         return;
3282
3283     // For now, lump all families but monospace together.
3284     if (childFont.genericFamily() != FontDescription::MonospaceFamily
3285         && parentFont.genericFamily() != FontDescription::MonospaceFamily)
3286         return;
3287
3288     // We know the parent is monospace or the child is monospace, and that font
3289     // size was unspecified. We want to scale our font size as appropriate.
3290     // If the font uses a keyword size, then we refetch from the table rather than
3291     // multiplying by our scale factor.
3292     float size;
3293     if (childFont.keywordSize())
3294         size = Style::fontSizeForKeyword(CSSValueXxSmall + childFont.keywordSize() - 1, childFont.useFixedDefaultSize(), document());
3295     else {
3296         Settings* settings = documentSettings();
3297         float fixedScaleFactor = (settings && settings->defaultFixedFontSize() && settings->defaultFontSize())
3298             ? static_cast<float>(settings->defaultFixedFontSize()) / settings->defaultFontSize()
3299             : 1;
3300         size = parentFont.useFixedDefaultSize() ?
3301                 childFont.specifiedSize() / fixedScaleFactor :
3302                 childFont.specifiedSize() * fixedScaleFactor;
3303     }
3304
3305     FontDescription newFontDescription(childFont);
3306     setFontSize(newFontDescription, size);
3307     style->setFontDescription(newFontDescription);
3308 }
3309
3310 void StyleResolver::initializeFontStyle(Settings* settings)
3311 {
3312     FontDescription fontDescription;
3313     fontDescription.setGenericFamily(FontDescription::StandardFamily);
3314     fontDescription.setRenderingMode(settings->fontRenderingMode());
3315     fontDescription.setUsePrinterFont(document().printing() || !settings->screenFontSubstitutionEnabled());
3316     const AtomicString& standardFontFamily = documentSettings()->standardFontFamily();
3317     if (!standardFontFamily.isEmpty())
3318         fontDescription.setOneFamily(standardFontFamily);
3319     fontDescription.setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
3320     setFontSize(fontDescription, Style::fontSizeForKeyword(CSSValueMedium, false, document()));
3321     m_state.style()->setLineHeight(RenderStyle::initialLineHeight());
3322     m_state.setLineHeightValue(0);
3323     setFontDescription(fontDescription);
3324 }
3325
3326 void StyleResolver::setFontSize(FontDescription& fontDescription, float size)
3327 {
3328     fontDescription.setSpecifiedSize(size);
3329     fontDescription.setComputedSize(Style::computedFontSizeFromSpecifiedSize(size, fontDescription.isAbsoluteSize(), useSVGZoomRules(), m_state.style(), document()));
3330 }
3331
3332 static Color colorForCSSValue(CSSValueID cssValueId)
3333 {
3334     struct ColorValue {
3335         CSSValueID cssValueId;
3336         RGBA32 color;
3337     };
3338
3339     static const ColorValue colorValues[] = {
3340         { CSSValueAqua, 0xFF00FFFF },
3341         { CSSValueBlack, 0xFF000000 },
3342         { CSSValueBlue, 0xFF0000FF },
3343         { CSSValueFuchsia, 0xFFFF00FF },
3344         { CSSValueGray, 0xFF808080 },
3345         { CSSValueGreen, 0xFF008000  },
3346         { CSSValueGrey, 0xFF808080 },
3347         { CSSValueLime, 0xFF00FF00 },
3348         { CSSValueMaroon, 0xFF800000 },
3349         { CSSValueNavy, 0xFF000080 },
3350         { CSSValueOlive, 0xFF808000  },
3351         { CSSValueOrange, 0xFFFFA500 },
3352         { CSSValuePurple, 0xFF800080 },
3353         { CSSValueRed, 0xFFFF0000 },
3354         { CSSValueSilver, 0xFFC0C0C0 },
3355         { CSSValueTeal, 0xFF008080  },
3356         { CSSValueTransparent, 0x00000000 },
3357         { CSSValueWhite, 0xFFFFFFFF },
3358         { CSSValueYellow, 0xFFFFFF00 },
3359         { CSSValueInvalid, CSSValueInvalid }
3360     };
3361
3362     for (const ColorValue* col = colorValues; col->cssValueId; ++col) {
3363         if (col->cssValueId == cssValueId)
3364             return col->color;
3365     }
3366     return RenderTheme::defaultTheme()->systemColor(cssValueId);
3367 }
3368
3369 bool StyleResolver::colorFromPrimitiveValueIsDerivedFromElement(CSSPrimitiveValue* value)
3370 {
3371     int ident = value->getValueID();
3372     switch (ident) {
3373     case CSSValueWebkitText:
3374     case CSSValueWebkitLink:
3375     case CSSValueWebkitActivelink:
3376     case CSSValueCurrentcolor:
3377         return true;
3378     default:
3379         return false;
3380     }
3381 }
3382
3383 Color StyleResolver::colorFromPrimitiveValue(CSSPrimitiveValue* value, bool forVisitedLink) const
3384 {
3385     if (value->isRGBColor())
3386         return Color(value->getRGBA32Value());
3387
3388     const State& state = m_state;
3389     CSSValueID ident = value->getValueID();
3390     switch (ident) {
3391     case 0:
3392         return Color();
3393     case CSSValueWebkitText:
3394         return state.document().textColor();
3395     case CSSValueWebkitLink:
3396         return (state.element()->isLink() && forVisitedLink) ? state.document().visitedLinkColor() : state.document().linkColor();
3397     case CSSValueWebkitActivelink:
3398         return state.document().activeLinkColor();
3399     case CSSValueWebkitFocusRingColor:
3400         return RenderTheme::focusRingColor();
3401     case CSSValueCurrentcolor:
3402         return state.style()->color();
3403     default:
3404         return colorForCSSValue(ident);
3405     }
3406 }
3407
3408 void StyleResolver::addViewportDependentMediaQueryResult(const MediaQueryExp* expr, bool result)
3409 {
3410     m_viewportDependentMediaQueryResults.append(adoptPtr(new MediaQueryResult(*expr, result)));
3411 }
3412
3413 bool StyleResolver::affectedByViewportChange() const
3414 {
3415     unsigned s = m_viewportDependentMediaQueryResults.size();
3416     for (unsigned i = 0; i < s; i++) {
3417         if (m_medium->eval(&m_viewportDependentMediaQueryResults[i]->m_expression) != m_viewportDependentMediaQueryResults[i]->m_result)
3418             return true;
3419     }
3420     return false;
3421 }
3422
3423 #if ENABLE(CSS_FILTERS)
3424 static FilterOperation::OperationType filterOperationForType(WebKitCSSFilterValue::FilterOperationType type)
3425 {
3426     switch (type) {
3427     case WebKitCSSFilterValue::ReferenceFilterOperation: