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