Improve RAII of StyleResolverState.

Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 41 matching lines @@
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/ElementRuleCollector.h"
 #include "core/css/FontFace.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/css/PageRuleCollector.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/resolver/AnimatedStyleBuilder.h"
+#include "core/css/resolver/ElementResolveContext.h"
 #include "core/css/resolver/MatchResult.h"
 #include "core/css/resolver/MediaQueryResult.h"
 #include "core/css/resolver/SharedStyleFinder.h"
 #include "core/css/resolver/StyleAdjuster.h"
 #include "core/css/resolver/StyleResolverParentScope.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/css/resolver/StyleResolverStats.h"
 #include "core/css/resolver/ViewportStyleResolver.h"
 #include "core/dom/CSSSelectorWatch.h"
 #include "core/dom/NodeRenderStyle.h"
@@ skipping 493 matching lines @@
         document().setHasNodesWithPlaceholderStyle();
         return s_styleNotYetAvailable;
     }
 
     didAccess();
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
     if (element == document().documentElement())
         resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), element, defaultParent);
 
-    if (sharingBehavior == AllowStyleSharing && state.parentStyle()) {
-        SharedStyleFinder styleFinder(state.elementContext(), m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
+    ElementResolveContext elementContext(document(), element, defaultParent);
+
+    if (sharingBehavior == AllowStyleSharing && elementContext.parentStyle()) {
+        SharedStyleFinder styleFinder(elementContext, m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
         if (RefPtr<RenderStyle> sharedStyle = styleFinder.findSharedStyle())
             return sharedStyle.release();
     }
 
-    ActiveAnimations* activeAnimations = element->activeAnimations();
-    const RenderStyle* baseRenderStyle = activeAnimations ? activeAnimations->baseRenderStyle() : nullptr;
+    StyleResolverState state(elementContext);
 
-    if (baseRenderStyle) {
-        state.setStyle(RenderStyle::clone(baseRenderStyle));
-    } else if (state.parentStyle()) {
-        state.setStyle(RenderStyle::create());
-        state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
-    } else {
-        state.setStyle(defaultStyleForElement());
-        state.setParentStyle(RenderStyle::clone(state.style()));
-    }
+    if (!elementContext.baseRenderStyle() && elementContext.parentStyle())
+        state.style()->inheritFrom(elementContext.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
+
     // contenteditable attribute (implemented by -webkit-user-modify) should
     // be propagated from shadow host to distributed node.
     if (state.distributedToInsertionPoint()) {
         if (Element* parent = element->parentElement()) {
             if (RenderStyle* styleOfShadowHost = parent->renderStyle())
                 state.style()->setUserModify(styleOfShadowHost->userModify());
         }
     }
 
     if (element->isLink()) {
         state.style()->setIsLink(true);
         EInsideLink linkState = state.elementLinkState();
         if (linkState != NotInsideLink) {
             bool forceVisited = InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoVisited);
             if (forceVisited)
                 linkState = InsideVisitedLink;
         }
         state.style()->setInsideLink(linkState);
     }
 
-    if (!baseRenderStyle) {
+    if (!elementContext.baseRenderStyle()) {
 
         bool needsCollection = false;
         CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(element, needsCollection);
         if (needsCollection)
             collectFeatures();
 
         ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
 
         matchAllRules(state, collector, matchingBehavior != MatchAllRulesExcludingSMIL);
 
         applyMatchedProperties(state, collector.matchedResult());
         applyCallbackSelectors(state);
 
         addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 
         // Cache our original display.
         state.style()->setOriginalDisplay(state.style()->display());
 
         adjustRenderStyle(state, element);
 
-        if (activeAnimations)
-            activeAnimations->updateBaseRenderStyle(state.style());
+        if (elementContext.activeAnimations())
+            elementContext.activeAnimations()->updateBaseRenderStyle(state.style());
     }
 
     // FIXME: The CSSWG wants to specify that the effects of animations are applied before
     // important rules, but this currently happens here as we require adjustment to have happened
     // before deciding which properties to transition.
     if (applyAnimatedProperties(state, element))
         adjustRenderStyle(state, element);
 
     if (isHTMLBodyElement(*element))
         document().textLinkColors().setTextColor(state.style()->color());
 
     setAnimationUpdateIfNeeded(state, *element);
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
 
     // Now return the style.
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(Element& element, const RenderStyle& elementStyle, RenderStyle* parentStyle, const StyleKeyframe* keyframe, const AtomicString& animationName)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(!hasPendingAuthorStyleSheets());
 
     if (&element == document().documentElement())
         resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), &element, parentStyle);
+    StyleResolverState state(document(), &element, RenderStyle::clone(&elementStyle), parentStyle);
 
     MatchResult result;
     result.addMatchedProperties(&keyframe->properties());
 
-    ASSERT(!state.style());
-
-    // Create the style
-    state.setStyle(RenderStyle::clone(&elementStyle));
-    state.setLineHeightValue(0);
 
     // We don't need to bother with !important. Since there is only ever one
     // decl, there's nothing to override. So just add the first properties.
     // We also don't need to bother with animation properties since the only
     // relevant one is animation-timing-function and we special-case that in
     // CSSAnimations.cpp
     bool inheritedOnly = false;
     applyMatchedProperties<HighPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
-    // Line-height is set when we are sure we decided on the font-size
-    if (state.lineHeightValue())
-        StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
-
     // Now do rest of the properties.
     applyMatchedProperties<LowPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     loadPendingResources(state);
 
     didAccess();
 
     return state.takeStyle();
 }
 
 // This function is used by the WebAnimations JavaScript API method animate().
 // FIXME: Remove this when animate() switches away from resolution-dependent parsing.
 PassRefPtrWillBeRawPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(Element& element, CSSPropertyID property, CSSValue& value)
 {
     RefPtr<RenderStyle> style;
     if (element.renderStyle())
         style = RenderStyle::clone(element.renderStyle());
     else
         style = RenderStyle::create();
-    StyleResolverState state(element.document(), &element);
-    state.setStyle(style);
+    StyleResolverState state(element.document(), &element, style);
     return createAnimatableValueSnapshot(state, property, value);
 }
 
 PassRefPtrWillBeRawPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(StyleResolverState& state, CSSPropertyID property, CSSValue& value)
 {
     StyleBuilder::applyProperty(property, state, &value);
     return CSSAnimatableValueFactory::create(property, *state.style());
 }
 
 PassRefPtrWillBeRawPtr<PseudoElement> StyleResolver::createPseudoElementIfNeeded(Element& parent, PseudoId pseudoId)
@@ skipping 11 matching lines @@
     if (!parentRenderer->canHaveGeneratedChildren())
         return nullptr;
 
     RenderStyle* parentStyle = parentRenderer->style();
     if (RenderStyle* cachedStyle = parentStyle->getCachedPseudoStyle(pseudoId)) {
         if (!pseudoElementRendererIsNeeded(cachedStyle))
             return nullptr;
         return PseudoElement::create(&parent, pseudoId);
     }
 
-    StyleResolverState state(document(), &parent, parentStyle);
-    if (!pseudoStyleForElementInternal(parent, pseudoId, parentStyle, state))
+    ElementResolveContext elementContext(document(), &parent, parentStyle);
+    StyleResolverState state(elementContext);
+    if (!pseudoStyleForElementInternal(pseudoId, parentStyle, state))
         return nullptr;
     RefPtr<RenderStyle> style = state.takeStyle();
     ASSERT(style);
     parentStyle->addCachedPseudoStyle(style);
 
     if (!pseudoElementRendererIsNeeded(style.get()))
         return nullptr;
 
     RefPtrWillBeRawPtr<PseudoElement> pseudo = PseudoElement::create(&parent, pseudoId);
 
     setAnimationUpdateIfNeeded(state, *pseudo);
     if (ActiveAnimations* activeAnimations = pseudo->activeAnimations())
         activeAnimations->cssAnimations().maybeApplyPendingUpdate(pseudo.get());
     return pseudo.release();
 }
 
-bool StyleResolver::pseudoStyleForElementInternal(Element& element, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle, StyleResolverState& state)
+bool StyleResolver::pseudoStyleForElementInternal(const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle, StyleResolverState& state)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(pseudoStyleRequest.pseudoId != FIRST_LINE_INHERITED);
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
-    Element* pseudoElement = element.pseudoElement(pseudoStyleRequest.pseudoId);
-
-    ActiveAnimations* activeAnimations = pseudoElement ? pseudoElement->activeAnimations() : nullptr;
-    const RenderStyle* baseRenderStyle = activeAnimations ? activeAnimations->baseRenderStyle() : nullptr;
-
-    if (baseRenderStyle) {
-        state.setStyle(RenderStyle::clone(baseRenderStyle));
-    } else if (pseudoStyleRequest.allowsInheritance(state.parentStyle())) {
-        state.setStyle(RenderStyle::create());
-        state.style()->inheritFrom(state.parentStyle());
-    } else {
-        state.setStyle(defaultStyleForElement());
-        state.setParentStyle(RenderStyle::clone(state.style()));
-    }
+    const ElementResolveContext& elementContext = state.elementContext();
+    Element* pseudoElement = elementContext.element()->pseudoElement(pseudoStyleRequest.pseudoId);
 
     state.style()->setStyleType(pseudoStyleRequest.pseudoId);
 
     // Since we don't use pseudo-elements in any of our quirk/print
     // user agent rules, don't waste time walking those rules.
 
-    if (!baseRenderStyle) {
+    if (!elementContext.baseRenderStyle()) {
+
+        if (pseudoStyleRequest.allowsInheritance(elementContext.parentStyle()))
+            state.style()->inheritFrom(elementContext.parentStyle());
+
         // Check UA, user and author rules.
-        ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
+        ElementRuleCollector collector(elementContext, m_selectorFilter, state.style());
         collector.setPseudoStyleRequest(pseudoStyleRequest);
 
         matchUARules(collector);
         matchAuthorRules(state.element(), collector, false);
 
         if (collector.matchedResult().matchedProperties.isEmpty())
             return false;
 
         applyMatchedProperties(state, collector.matchedResult());
         applyCallbackSelectors(state);
 
         addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 
         // Cache our original display.
         state.style()->setOriginalDisplay(state.style()->display());
 
         // FIXME: Passing 0 as the Element* introduces a lot of complexity
         // in the adjustRenderStyle code.
         adjustRenderStyle(state, 0);
 
-        if (activeAnimations)
-            activeAnimations->updateBaseRenderStyle(state.style());
+        if (elementContext.activeAnimations())
+            elementContext.activeAnimations()->updateBaseRenderStyle(state.style());
     }
 
     // FIXME: The CSSWG wants to specify that the effects of animations are applied before
     // important rules, but this currently happens here as we require adjustment to have happened
     // before deciding which properties to transition.
     if (applyAnimatedProperties(state, pseudoElement))
         adjustRenderStyle(state, 0);
 
     didAccess();
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
 
     return true;
 }
 
 PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(Element* element, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle)
 {
     ASSERT(parentStyle);
     if (!element)
         return nullptr;
 
-    StyleResolverState state(document(), element, parentStyle);
-    if (!pseudoStyleForElementInternal(*element, pseudoStyleRequest, parentStyle, state)) {
+    ElementResolveContext elementContext(document(), element, parentStyle);
+    StyleResolverState state(elementContext);
+    if (!pseudoStyleForElementInternal(pseudoStyleRequest, parentStyle, state)) {
         if (pseudoStyleRequest.type == PseudoStyleRequest::ForRenderer)
             return nullptr;
         return state.takeStyle();
     }
 
     if (PseudoElement* pseudoElement = element->pseudoElement(pseudoStyleRequest.pseudoId))
         setAnimationUpdateIfNeeded(state, *pseudoElement);
 
     // Now return the style.
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
 {
     ASSERT(!hasPendingAuthorStyleSheets());
     resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), document().documentElement()); // m_rootElementStyle will be set to the document style.
+    StyleResolverState state(document(), document().documentElement(), RenderStyle::create()); // m_rootElementStyle will be set to the document style.
 
-    state.setStyle(RenderStyle::create());
     const RenderStyle* rootElementStyle = state.rootElementStyle() ? state.rootElementStyle() : document().renderStyle();
     ASSERT(rootElementStyle);
     state.style()->inheritFrom(rootElementStyle);
 
     PageRuleCollector collector(rootElementStyle, pageIndex);
 
     collector.matchPageRules(CSSDefaultStyleSheets::instance().defaultPrintStyle());
 
     if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
         scopedResolver->matchPageRules(collector);
 
-    state.setLineHeightValue(0);
     bool inheritedOnly = false;
 
     MatchResult& result = collector.matchedResult();
     applyMatchedProperties<HighPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
-    // Line-height is set when we are sure we decided on the font-size.
-    if (state.lineHeightValue())
-        StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
-
     applyMatchedProperties<LowPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 
     loadPendingResources(state);
 
     didAccess();
 
     // Now return the style.
     return state.takeStyle();
 }
 
 void StyleResolver::collectViewportRules()
 {
     CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
     viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultStyle(), ViewportStyleResolver::UserAgentOrigin);
 
     if (!InspectorInstrumentation::applyViewportStyleOverride(&document(), this))
         viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultViewportStyle(), ViewportStyleResolver::UserAgentOrigin);
 
     if (document().isMobileDocument())
         viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultXHTMLMobileProfileStyle(), ViewportStyleResolver::UserAgentOrigin);
 
     if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
         scopedResolver->collectViewportRulesTo(this);
 
     viewportStyleResolver()->resolve();
 }
 
-PassRefPtr<RenderStyle> StyleResolver::defaultStyleForElement()
-{
-    StyleResolverState state(document(), 0);
-    state.setStyle(RenderStyle::create());
-    state.style()->setLineHeight(RenderStyle::initialLineHeight());
-    state.setLineHeightValue(0);
-    state.fontBuilder().setInitial(state.style()->effectiveZoom());
-    state.style()->font().update(document().styleEngine()->fontSelector());
-    return state.takeStyle();
-}
-
 PassRefPtr<RenderStyle> StyleResolver::styleForText(Text* textNode)
 {
     ASSERT(textNode);
 
     Node* parentNode = NodeRenderingTraversal::parent(textNode);
     if (!parentNode || !parentNode->renderStyle())
-        return defaultStyleForElement();
+        return StyleResolverState::defaultStyleForElement(document());
     return parentNode->renderStyle();
 }
 
 void StyleResolver::updateFont(StyleResolverState& state)
 {
     state.fontBuilder().createFont(document().styleEngine()->fontSelector(), state.parentStyle(), state.style());
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleList> StyleResolver::styleRulesForElement(Element* element, unsigned rulesToInclude)
 {
     ASSERT(element);
-    StyleResolverState state(document(), element);
-    ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
+    ElementResolveContext elementContext(document(), element, nullptr);
+    ElementRuleCollector collector(elementContext, m_selectorFilter, nullptr);
     collector.setMode(SelectorChecker::CollectingStyleRules);
     collectPseudoRulesForElement(element, collector, NOPSEUDO, rulesToInclude);
     return collector.matchedStyleRuleList();
 }
 
 PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::pseudoCSSRulesForElement(Element* element, PseudoId pseudoId, unsigned rulesToInclude)
 {
     ASSERT(element);
-    StyleResolverState state(document(), element);
-    ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
+    ElementResolveContext elementContext(document(), element, nullptr);
+    ElementRuleCollector collector(elementContext, m_selectorFilter, nullptr);
     collector.setMode(SelectorChecker::CollectingCSSRules);
     collectPseudoRulesForElement(element, collector, pseudoId, rulesToInclude);
     return collector.matchedCSSRuleList();
 }
 
 PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::cssRulesForElement(Element* element, unsigned rulesToInclude)
 {
     return pseudoCSSRulesForElement(element, NOPSEUDO, rulesToInclude);
 }
 
@@ skipping 284 matching lines @@
 // lastCSSPropertyId<HighPriorityProperties>.
 template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::HighPriorityProperties>()
 {
     COMPILE_ASSERT(CSSPropertyColor == firstCSSProperty, CSS_color_is_first_high_priority_property);
     return CSSPropertyColor;
 }
 
 // This method returns the last CSSPropertyId of high priority properties.
 template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::HighPriorityProperties>()
 {
-    COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyColor + 17, CSS_line_height_is_end_of_high_prioity_property_range);
-    COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyLineHeight - 1, CSS_zoom_is_before_line_height);
-    return CSSPropertyLineHeight;
+    COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 16, CSS_zoom_is_end_of_high_priority_property_range);
+    COMPILE_ASSERT(CSSPropertyTextRendering == CSSPropertyZoom - 1, CSS_text_rendering_is_before_zoom);
+    return CSSPropertyZoom;
 }
 
 // This method returns the first CSSPropertyId of remaining properties,
 // i.e. low priority properties. No properties depend on low priority
 // properties. So we don't need to resolve such properties quickly.
 // All low priority properties are obtained by using
 // firstCSSPropertyId<LowPriorityProperties> and
 // lastCSSPropertyId<LowPriorityProperties>.
 template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::LowPriorityProperties>()
 {
-    COMPILE_ASSERT(CSSPropertyAlignContent == CSSPropertyLineHeight + 1, CSS_background_is_first_low_priority_property);
+    COMPILE_ASSERT(CSSPropertyAlignContent == CSSPropertyZoom + 1, CSS_align_content_is_first_low_priority_property);
     return CSSPropertyAlignContent;
 }
 
 // This method returns the last CSSPropertyId of low priority properties.
 template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::LowPriorityProperties>()
 {
     return static_cast<CSSPropertyID>(lastCSSProperty);
 }
 
 template <StyleResolver::StyleApplicationPass pass>
@@ skipping 62 matching lines @@
             ASSERT(!current.value()->isInheritedValue());
             continue;
         }
 
         if (propertyWhitelistType == PropertyWhitelistCue && !isValidCueStyleProperty(property))
             continue;
         if (propertyWhitelistType == PropertyWhitelistFirstLetter && !isValidFirstLetterStyleProperty(property))
             continue;
         if (!isPropertyForPass<pass>(property))
             continue;
-        if (pass == HighPriorityProperties && property == CSSPropertyLineHeight)
-            state.setLineHeightValue(current.value());
-        else
-            StyleBuilder::applyProperty(current.id(), state, current.value());
+
+        StyleBuilder::applyProperty(current.id(), state, current.value());
     }
 }
 
 template <StyleResolver::StyleApplicationPass pass>
 void StyleResolver::applyMatchedProperties(StyleResolverState& state, const MatchResult& matchResult, bool isImportant, int startIndex, int endIndex, bool inheritedOnly)
 {
     if (startIndex == -1)
         return;
 
     if (state.style()->insideLink() != NotInsideLink) {
@@ skipping 62 matching lines @@
             state.style()->setInsideLink(linkStatus);
             return;
         }
         applyInheritedOnly = true;
     }
 
     // Now we have all of the matched rules in the appropriate order. Walk the rules and apply
     // high-priority properties first, i.e., those properties that other properties depend on.
     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
     // and (4) normal important.
-    state.setLineHeightValue(0);
     applyMatchedProperties<HighPriorityProperties>(state, matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
     applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
     if (UNLIKELY(isSVGForeignObjectElement(element))) {
         // RenderSVGRoot handles zooming for the whole SVG subtree, so foreignObject content should not be scaled again.
         //
         // FIXME: The following hijacks the zoom property for foreignObject so that children of foreignObject get the
         // correct font-size in case of zooming. 'zoom' is part of HighPriorityProperties, along with other font-related
         // properties used as input to the FontBuilder, so resetting it here may cause the FontBuilder to recompute the
         // font used as inheritable font for foreignObject content. If we want to support zoom on foreignObject we'll
         // need to find another way of handling the SVG zoom model.
         state.setEffectiveZoom(RenderStyle::initialZoom());
     }
 
     if (cachedMatchedProperties && cachedMatchedProperties->renderStyle->effectiveZoom() != state.style()->effectiveZoom()) {
         state.fontBuilder().setFontDirty(true);
         applyInheritedOnly = false;
     }
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
-    // Line-height is set when we are sure we decided on the font-size.
-    if (state.lineHeightValue())
-        StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
-
     // Many properties depend on the font. If it changes we just apply all properties.
     if (cachedMatchedProperties && cachedMatchedProperties->renderStyle->fontDescription() != state.style()->fontDescription())
         applyInheritedOnly = false;
 
     // Now do the normal priority UA properties.
     applyMatchedProperties<LowPriorityProperties>(state, matchResult, false, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
     // Cache the UA properties to pass them to RenderTheme in adjustRenderStyle.
     state.cacheUserAgentBorderAndBackground();
 
@@ skipping 60 matching lines @@
     if (!m_styleResolverStats)
         return;
     fprintf(stderr, "=== Style Resolver Stats (resolve #%u) (%s) ===\n", ++m_styleResolverStatsSequence, document().url().string().utf8().data());
     fprintf(stderr, "%s\n", m_styleResolverStats->report().utf8().data());
     fprintf(stderr, "== Totals ==\n");
     fprintf(stderr, "%s\n", m_styleResolverStatsTotals->report().utf8().data());
 }
 
 void StyleResolver::applyPropertiesToStyle(const CSSPropertyValue* properties, size_t count, RenderStyle* style)
 {
-    StyleResolverState state(document(), document().documentElement(), style);
-    state.setStyle(style);
+    StyleResolverState state(document(), document().documentElement(), style, style);
 
     for (size_t i = 0; i < count; ++i) {
         if (properties[i].value) {
             // As described in BUG66291, setting font-size and line-height on a font may entail a CSSPrimitiveValue::computeLengthDouble call,
             // which assumes the fontMetrics are available for the affected font, otherwise a crash occurs (see http://trac.webkit.org/changeset/96122).
             // The updateFont() call below updates the fontMetrics and ensure the proper setting of font-size and line-height.
             switch (properties[i].property) {
             case CSSPropertyFontSize:
             case CSSPropertyLineHeight:
                 updateFont(state);
@@ skipping 34 matching lines @@
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingRules);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink