Changeset 142757 in webkit

Timestamp:

Feb 13, 2013 9:26:41 AM (11 years ago)

Author:

tasak@google.com

Message:

Source/WebCore: [Refactoring] StyleResolver::State should have methods to access its member variables.
​https://bugs.webkit.org/show_bug.cgi?id=108563

Reviewed by Antti Koivisto.

Made all member variables private and added methods to access the
variables, because most of the member variables are read-only.
We don't need to update those read-only variables while resolving
styles.

No new tests, because just refactoring.

• css/SVGCSSStyleSelector.cpp:

(WebCore::StyleResolver::applySVGProperty):

• css/StyleResolver.cpp:

(WebCore):
(WebCore::StyleResolver::collectMatchingRules):
(WebCore::StyleResolver::collectMatchingRulesForRegion):
(WebCore::StyleResolver::sortAndTransferMatchedRules):
(WebCore::StyleResolver::matchScopedAuthorRules):
(WebCore::StyleResolver::styleSharingCandidateMatchesHostRules):
(WebCore::StyleResolver::matchHostRules):
(WebCore::StyleResolver::matchAuthorRules):
(WebCore::StyleResolver::matchUserRules):
(WebCore::StyleResolver::matchUARules):
(WebCore::StyleResolver::collectMatchingRulesForList):
(WebCore::StyleResolver::sortMatchedRules):
(WebCore::StyleResolver::matchAllRules):
(WebCore::StyleResolver::State::initElement):
(WebCore::StyleResolver::initElement):
Modified to invoke m_state.initElement if a given element is
different from current m_state's element.
(WebCore::StyleResolver::State::initForStyleResolve):
Moved from StyleResolver.
(WebCore::StyleResolver::styleSharingCandidateMatchesRuleSet):
(WebCore::StyleResolver::canShareStyleWithControl):
(WebCore::StyleResolver::sharingCandidateHasIdenticalStyleAffectingAttributes):
(WebCore::StyleResolver::canShareStyleWithElement):
(WebCore::StyleResolver::locateSharedStyle):
(WebCore::StyleResolver::styleForElement):
(WebCore::StyleResolver::styleForKeyframe):
(WebCore::StyleResolver::keyframeStylesForAnimation):
(WebCore::StyleResolver::pseudoStyleForElement):
Changed ASSERT in the first line. ASSERT(m_state.parentStyle) would be
wrong, because it depends on previous resolving. However,
initForStyleResolve will also update m_state.parentStyle. No code in
pseudoStyleForElement depends on previous resolving state.
(WebCore::StyleResolver::styleForPage):
(WebCore::StyleResolver::defaultStyleForElement):
(WebCore::StyleResolver::adjustRenderStyle):
(WebCore::StyleResolver::updateFont):
(WebCore::StyleResolver::pseudoStyleRulesForElement):
(WebCore::StyleResolver::ruleMatches):
Added one more parameter, dynamicPseudo, because dynamicPseudo in
State class is just used for returning matched pseudo style from
this ruleMatches to collectMatchingRulesForList. No need to keep
dynamicPseudo while resolving styles.
(WebCore::StyleResolver::checkRegionSelector):
Removed m_pseudoStyle = NOPSEUDO, because this method uses just
SelectorChecker::matched. SelectorChecker doesn't see StyleResolver's
m_pseudoStyle directly. Need to use SelectorCheckerContext. So no
need to set m_pseudoStyle to be NOPSEUDO.
(WebCore::StyleResolver::applyProperties):
(WebCore::StyleResolver::applyMatchedProperties):
(WebCore::StyleResolver::isLeftPage):
(WebCore::StyleResolver::applyPropertyToStyle):
(WebCore::StyleResolver::useSVGZoomRules):
(WebCore::createGridTrackBreadth):
(WebCore::StyleResolver::resolveVariables):
(WebCore::StyleResolver::applyProperty):
(WebCore::StyleResolver::cachedOrPendingFromValue):
(WebCore::StyleResolver::generatedOrPendingFromValue):
(WebCore::StyleResolver::setOrPendingFromValue):
(WebCore::StyleResolver::cursorOrPendingFromValue):
(WebCore::StyleResolver::checkForTextSizeAdjust):
(WebCore::StyleResolver::initializeFontStyle):
(WebCore::StyleResolver::setFontSize):
(WebCore::StyleResolver::colorFromPrimitiveValue):
(WebCore::StyleResolver::loadPendingSVGDocuments):
(WebCore::StyleResolver::cachedOrPendingStyleShaderFromValue):
(WebCore::StyleResolver::loadPendingShaders):
(WebCore::StyleResolver::parseCustomFilterTransformParameter):
(WebCore::StyleResolver::createFilterOperations):
(WebCore::StyleResolver::loadPendingImage):
(WebCore::StyleResolver::loadPendingImages):

• css/StyleResolver.h:

(WebCore::StyleResolver::style):
(WebCore::StyleResolver::parentStyle):
(WebCore::StyleResolver::rootElementStyle):
(WebCore::StyleResolver::element):
(WebCore::StyleResolver::hasParentNode):
(StyleResolver):
(WebCore::StyleResolver::State::State):
(State):
(WebCore::StyleResolver::State::clear):
Modified to use clear at the end of styleForElement.
(WebCore::StyleResolver::State::document):
(WebCore::StyleResolver::State::element):
(WebCore::StyleResolver::State::styledElement):
(WebCore::StyleResolver::State::setStyle):
(WebCore::StyleResolver::State::style):
(WebCore::StyleResolver::State::takeStyle):
(WebCore::StyleResolver::State::ensureRuleList):
(WebCore::StyleResolver::State::takeRuleList):
(WebCore::StyleResolver::State::parentNode):
(WebCore::StyleResolver::State::setParentStyle):
(WebCore::StyleResolver::State::parentStyle):
(WebCore::StyleResolver::State::rootElementStyle):
(WebCore::StyleResolver::State::regionForStyling):
(WebCore::StyleResolver::State::setSameOriginOnly):
(WebCore::StyleResolver::State::isSameOriginOnly):
(WebCore::StyleResolver::State::pseudoStyle):
(WebCore::StyleResolver::State::elementLinkState):
(WebCore::StyleResolver::State::distributedToInsertionPoint):
(WebCore::StyleResolver::State::setElementAffectedByClassRules):
(WebCore::StyleResolver::State::elementAffectedByClassRules):
(WebCore::StyleResolver::State::setApplyPropertyToRegularStyle):
(WebCore::StyleResolver::State::setApplyPropertyToVisitedLinkStyle):
(WebCore::StyleResolver::State::applyPropertyToRegularStyle):
(WebCore::StyleResolver::State::applyPropertyToVisitedLinkStyle):
(WebCore::StyleResolver::State::pendingImageProperties):
(WebCore::StyleResolver::State::pendingSVGDocuments):
(WebCore::StyleResolver::State::setHasPendingShaders):
(WebCore::StyleResolver::State::hasPendingShaders):
(WebCore::StyleResolver::State::setLineHeightValue):
(WebCore::StyleResolver::State::lineHeightValue):
(WebCore::StyleResolver::State::setFontDirty):
(WebCore::StyleResolver::State::fontDirty):
(WebCore::StyleResolver::State::cacheBorderAndBackground):
(WebCore::StyleResolver::State::hasUAAppearance):
(WebCore::StyleResolver::State::borderData):
(WebCore::StyleResolver::State::backgroundData):
(WebCore::StyleResolver::State::backgroundColor):
(WebCore::StyleResolver::State::fontDescription):
(WebCore::StyleResolver::State::parentFontDescription):
(WebCore::StyleResolver::State::setFontDescription):
(WebCore::StyleResolver::State::setZoom):
(WebCore::StyleResolver::State::setEffectiveZoom):
(WebCore::StyleResolver::State::setTextSizeAdjust):
(WebCore::StyleResolver::State::setWritingMode):
(WebCore::StyleResolver::State::setTextOrientation):
fontDescription, ... and setTextOrientation were moved from
StyleResolver.
(WebCore::StyleResolver::State::matchedRules):
(WebCore::StyleResolver::State::addMatchedRule):
Moved from StyleResolver.
(WebCore::StyleResolver::applyPropertyToRegularStyle):
(WebCore::StyleResolver::applyPropertyToVisitedLinkStyle):
(WebCore::StyleResolver::fontDescription):
(WebCore::StyleResolver::parentFontDescription):
(WebCore::StyleResolver::setFontDescription):
(WebCore::StyleResolver::setZoom):
(WebCore::StyleResolver::setEffectiveZoom):
(WebCore::StyleResolver::setTextSizeAdjust):
(WebCore::StyleResolver::setWritingMode):
(WebCore::StyleResolver::setTextOrientation):
These fontDescription, ..., setTextOrientation are wrappers to
invoke State's methods. StyleBuilder still depends on StyleResolver
and invokes these methods. So we need these wrappers.

LayoutTests: [Refactoring] StyleResolver::State should have methods to access its me
​https://bugs.webkit.org/show_bug.cgi?id=108563

Reviewed by Antti Koivisto.

• inspector/styles/region-style-crash-expected.txt:

Rebaseline. Since inspector hasn't supported CSS region styles yet,
region-style-crash.html has no CSS region styles as its result.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/inspector/styles/region-style-crash-expected.txt (modified) (2 diffs)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/css/SVGCSSStyleSelector.cpp (modified) (17 diffs)
• Source/WebCore/css/StyleResolver.cpp (modified) (143 diffs)
• Source/WebCore/css/StyleResolver.h (modified) (7 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2013-02-13  Takashi Sakamoto  <tasak@google.com>
+
+        [Refactoring] StyleResolver::State should have methods to access its me
+        https://bugs.webkit.org/show_bug.cgi?id=108563
+
+        Reviewed by Antti Koivisto.
+
+        * inspector/styles/region-style-crash-expected.txt:
+        Rebaseline. Since inspector hasn't supported CSS region styles yet,
+        region-style-crash.html has no CSS region styles as its result.
+
 2013-02-13  Rashmi Shyamasundar  <rashmi.s2@samsung.com>
 

trunk/LayoutTests/inspector/styles/region-style-crash-expected.txt

@@ -14 +14 @@
 ======== Matched CSS Rules ========
 [expanded] 
-#p1  { (region-style-crash.html:8)
-
-[expanded] 
 #p1  { (region-style-crash.html:6)
 color: #ff0000;
@@ -29 +26 @@
 
 
-======== Pseudo ::first-line element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
 
-
-======== Pseudo ::first-letter element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::before element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::after element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::selection element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::-webkit-scrollbar element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::-webkit-file-upload-button element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::-webkit-input-placeholder element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::-webkit-slider-thumb element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::-webkit-search-cancel-button element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::-webkit-search-decoration element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::-webkit-search-results-decoration element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-======== Pseudo ::-webkit-search-results-button element ========
-[expanded] 
-#p1  { (region-style-crash.html:8)
-
-
-

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-02-13  Takashi Sakamoto  <tasak@google.com>
+
+        [Refactoring] StyleResolver::State should have methods to access its member variables.
+        https://bugs.webkit.org/show_bug.cgi?id=108563
+
+        Reviewed by Antti Koivisto.
+
+        Made all member variables private and added methods to access the
+        variables, because most of the member variables are read-only.
+        We don't need to update those read-only variables while resolving
+        styles.
+
+        No new tests, because just refactoring.
+
+        * css/SVGCSSStyleSelector.cpp:
+        (WebCore::StyleResolver::applySVGProperty):
+        * css/StyleResolver.cpp:
+        (WebCore):
+        (WebCore::StyleResolver::collectMatchingRules):
+        (WebCore::StyleResolver::collectMatchingRulesForRegion):
+        (WebCore::StyleResolver::sortAndTransferMatchedRules):
+        (WebCore::StyleResolver::matchScopedAuthorRules):
+        (WebCore::StyleResolver::styleSharingCandidateMatchesHostRules):
+        (WebCore::StyleResolver::matchHostRules):
+        (WebCore::StyleResolver::matchAuthorRules):
+        (WebCore::StyleResolver::matchUserRules):
+        (WebCore::StyleResolver::matchUARules):
+        (WebCore::StyleResolver::collectMatchingRulesForList):
+        (WebCore::StyleResolver::sortMatchedRules):
+        (WebCore::StyleResolver::matchAllRules):
+        (WebCore::StyleResolver::State::initElement):
+        (WebCore::StyleResolver::initElement):
+        Modified to invoke m_state.initElement if a given element is
+        different from current m_state's element.
+        (WebCore::StyleResolver::State::initForStyleResolve):
+        Moved from StyleResolver.
+        (WebCore::StyleResolver::styleSharingCandidateMatchesRuleSet):
+        (WebCore::StyleResolver::canShareStyleWithControl):
+        (WebCore::StyleResolver::sharingCandidateHasIdenticalStyleAffectingAttributes):
+        (WebCore::StyleResolver::canShareStyleWithElement):
+        (WebCore::StyleResolver::locateSharedStyle):
+        (WebCore::StyleResolver::styleForElement):
+        (WebCore::StyleResolver::styleForKeyframe):
+        (WebCore::StyleResolver::keyframeStylesForAnimation):
+        (WebCore::StyleResolver::pseudoStyleForElement):
+        Changed ASSERT in the first line. ASSERT(m_state.parentStyle) would be
+        wrong, because it depends on previous resolving. However,
+        initForStyleResolve will also update m_state.parentStyle. No code in
+        pseudoStyleForElement depends on previous resolving state.
+        (WebCore::StyleResolver::styleForPage):
+        (WebCore::StyleResolver::defaultStyleForElement):
+        (WebCore::StyleResolver::adjustRenderStyle):
+        (WebCore::StyleResolver::updateFont):
+        (WebCore::StyleResolver::pseudoStyleRulesForElement):
+        (WebCore::StyleResolver::ruleMatches):
+        Added one more parameter, dynamicPseudo, because dynamicPseudo in
+        State class is just used for returning matched pseudo style from
+        this ruleMatches to collectMatchingRulesForList. No need to keep
+        dynamicPseudo while resolving styles.
+        (WebCore::StyleResolver::checkRegionSelector):
+        Removed m_pseudoStyle = NOPSEUDO, because this method uses just
+        SelectorChecker::matched. SelectorChecker doesn't see StyleResolver's
+        m_pseudoStyle directly. Need to use SelectorCheckerContext. So no
+        need to set m_pseudoStyle to be NOPSEUDO.
+        (WebCore::StyleResolver::applyProperties):
+        (WebCore::StyleResolver::applyMatchedProperties):
+        (WebCore::StyleResolver::isLeftPage):
+        (WebCore::StyleResolver::applyPropertyToStyle):
+        (WebCore::StyleResolver::useSVGZoomRules):
+        (WebCore::createGridTrackBreadth):
+        (WebCore::StyleResolver::resolveVariables):
+        (WebCore::StyleResolver::applyProperty):
+        (WebCore::StyleResolver::cachedOrPendingFromValue):
+        (WebCore::StyleResolver::generatedOrPendingFromValue):
+        (WebCore::StyleResolver::setOrPendingFromValue):
+        (WebCore::StyleResolver::cursorOrPendingFromValue):
+        (WebCore::StyleResolver::checkForTextSizeAdjust):
+        (WebCore::StyleResolver::initializeFontStyle):
+        (WebCore::StyleResolver::setFontSize):
+        (WebCore::StyleResolver::colorFromPrimitiveValue):
+        (WebCore::StyleResolver::loadPendingSVGDocuments):
+        (WebCore::StyleResolver::cachedOrPendingStyleShaderFromValue):
+        (WebCore::StyleResolver::loadPendingShaders):
+        (WebCore::StyleResolver::parseCustomFilterTransformParameter):
+        (WebCore::StyleResolver::createFilterOperations):
+        (WebCore::StyleResolver::loadPendingImage):
+        (WebCore::StyleResolver::loadPendingImages):
+        * css/StyleResolver.h:
+        (WebCore::StyleResolver::style):
+        (WebCore::StyleResolver::parentStyle):
+        (WebCore::StyleResolver::rootElementStyle):
+        (WebCore::StyleResolver::element):
+        (WebCore::StyleResolver::hasParentNode):
+        (StyleResolver):
+        (WebCore::StyleResolver::State::State):
+        (State):
+        (WebCore::StyleResolver::State::clear):
+        Modified to use clear at the end of styleForElement.
+        (WebCore::StyleResolver::State::document):
+        (WebCore::StyleResolver::State::element):
+        (WebCore::StyleResolver::State::styledElement):
+        (WebCore::StyleResolver::State::setStyle):
+        (WebCore::StyleResolver::State::style):
+        (WebCore::StyleResolver::State::takeStyle):
+        (WebCore::StyleResolver::State::ensureRuleList):
+        (WebCore::StyleResolver::State::takeRuleList):
+        (WebCore::StyleResolver::State::parentNode):
+        (WebCore::StyleResolver::State::setParentStyle):
+        (WebCore::StyleResolver::State::parentStyle):
+        (WebCore::StyleResolver::State::rootElementStyle):
+        (WebCore::StyleResolver::State::regionForStyling):
+        (WebCore::StyleResolver::State::setSameOriginOnly):
+        (WebCore::StyleResolver::State::isSameOriginOnly):
+        (WebCore::StyleResolver::State::pseudoStyle):
+        (WebCore::StyleResolver::State::elementLinkState):
+        (WebCore::StyleResolver::State::distributedToInsertionPoint):
+        (WebCore::StyleResolver::State::setElementAffectedByClassRules):
+        (WebCore::StyleResolver::State::elementAffectedByClassRules):
+        (WebCore::StyleResolver::State::setApplyPropertyToRegularStyle):
+        (WebCore::StyleResolver::State::setApplyPropertyToVisitedLinkStyle):
+        (WebCore::StyleResolver::State::applyPropertyToRegularStyle):
+        (WebCore::StyleResolver::State::applyPropertyToVisitedLinkStyle):
+        (WebCore::StyleResolver::State::pendingImageProperties):
+        (WebCore::StyleResolver::State::pendingSVGDocuments):
+        (WebCore::StyleResolver::State::setHasPendingShaders):
+        (WebCore::StyleResolver::State::hasPendingShaders):
+        (WebCore::StyleResolver::State::setLineHeightValue):
+        (WebCore::StyleResolver::State::lineHeightValue):
+        (WebCore::StyleResolver::State::setFontDirty):
+        (WebCore::StyleResolver::State::fontDirty):
+        (WebCore::StyleResolver::State::cacheBorderAndBackground):
+        (WebCore::StyleResolver::State::hasUAAppearance):
+        (WebCore::StyleResolver::State::borderData):
+        (WebCore::StyleResolver::State::backgroundData):
+        (WebCore::StyleResolver::State::backgroundColor):
+        (WebCore::StyleResolver::State::fontDescription):
+        (WebCore::StyleResolver::State::parentFontDescription):
+        (WebCore::StyleResolver::State::setFontDescription):
+        (WebCore::StyleResolver::State::setZoom):
+        (WebCore::StyleResolver::State::setEffectiveZoom):
+        (WebCore::StyleResolver::State::setTextSizeAdjust):
+        (WebCore::StyleResolver::State::setWritingMode):
+        (WebCore::StyleResolver::State::setTextOrientation):
+        fontDescription, ... and setTextOrientation were moved from
+        StyleResolver.
+        (WebCore::StyleResolver::State::matchedRules):
+        (WebCore::StyleResolver::State::addMatchedRule):
+        Moved from StyleResolver.
+        (WebCore::StyleResolver::applyPropertyToRegularStyle):
+        (WebCore::StyleResolver::applyPropertyToVisitedLinkStyle):
+        (WebCore::StyleResolver::fontDescription):
+        (WebCore::StyleResolver::parentFontDescription):
+        (WebCore::StyleResolver::setFontDescription):
+        (WebCore::StyleResolver::setZoom):
+        (WebCore::StyleResolver::setEffectiveZoom):
+        (WebCore::StyleResolver::setTextSizeAdjust):
+        (WebCore::StyleResolver::setWritingMode):
+        (WebCore::StyleResolver::setTextOrientation):
+        These fontDescription, ..., setTextOrientation are wrappers to
+        invoke State's methods. StyleBuilder still depends on StyleResolver
+        and invokes these methods. So we need these wrappers.
+
 2013-02-13  Allan Sandfeld Jensen  <allan.jensen@digia.com>
 

trunk/Source/WebCore/css/SVGCSSStyleSelector.cpp

@@ -50 +50 @@
 if (isInherit) \
 { \
-    svgstyle->set##Prop(state.parentStyle->svgStyle()->prop()); \
+    svgstyle->set##Prop(state.parentStyle()->svgStyle()->prop()); \
     return; \
 }
@@ -111 +111 @@
 
     const State& state = m_state;
-    SVGRenderStyle* svgstyle = state.style->accessSVGStyle();
-
-    bool isInherit = state.parentNode && value->isInheritedValue();
-    bool isInitial = value->isInitialValue() || (!state.parentNode && value->isInheritedValue());
+    SVGRenderStyle* svgstyle = state.style()->accessSVGStyle();
+
+    bool isInherit = state.parentNode() && value->isInheritedValue();
+    bool isInitial = value->isInitialValue() || (!state.parentNode() && value->isInheritedValue());
 
     // What follows is a list that maps the CSS properties into their
@@ -231 +231 @@
         {
             if (isInherit) {
-                const SVGRenderStyle* svgParentStyle = state.parentStyle->svgStyle();
+                const SVGRenderStyle* svgParentStyle = state.parentStyle()->svgStyle();
                 svgstyle->setFillPaint(svgParentStyle->fillPaintType(), svgParentStyle->fillPaintColor(), svgParentStyle->fillPaintUri(), applyPropertyToRegularStyle(), applyPropertyToVisitedLinkStyle());
                 return;
@@ -241 +241 @@
             if (value->isSVGPaint()) {
                 SVGPaint* svgPaint = static_cast<SVGPaint*>(value);
-                svgstyle->setFillPaint(svgPaint->paintType(), colorFromSVGColorCSSValue(svgPaint, state.style->color()), svgPaint->uri(), applyPropertyToRegularStyle(), applyPropertyToVisitedLinkStyle());
+                svgstyle->setFillPaint(svgPaint->paintType(), colorFromSVGColorCSSValue(svgPaint, state.style()->color()), svgPaint->uri(), applyPropertyToRegularStyle(), applyPropertyToVisitedLinkStyle());
             }
             break;
@@ -248 +248 @@
         {
             if (isInherit) {
-                const SVGRenderStyle* svgParentStyle = state.parentStyle->svgStyle();
+                const SVGRenderStyle* svgParentStyle = state.parentStyle()->svgStyle();
                 svgstyle->setStrokePaint(svgParentStyle->strokePaintType(), svgParentStyle->strokePaintColor(), svgParentStyle->strokePaintUri(), applyPropertyToRegularStyle(), applyPropertyToVisitedLinkStyle());
                 return;
@@ -258 +258 @@
             if (value->isSVGPaint()) {
                 SVGPaint* svgPaint = static_cast<SVGPaint*>(value);
-                svgstyle->setStrokePaint(svgPaint->paintType(), colorFromSVGColorCSSValue(svgPaint, state.style->color()), svgPaint->uri(), applyPropertyToRegularStyle(), applyPropertyToVisitedLinkStyle());
+                svgstyle->setStrokePaint(svgPaint->paintType(), colorFromSVGColorCSSValue(svgPaint, state.style()->color()), svgPaint->uri(), applyPropertyToRegularStyle(), applyPropertyToVisitedLinkStyle());
             }
             break;
@@ -365 +365 @@
                 s = primitiveValue->getStringValue();
 
-            svgstyle->setMarkerStartResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.element->document()));
+            svgstyle->setMarkerStartResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.document()));
             break;
         }
@@ -379 +379 @@
                 s = primitiveValue->getStringValue();
 
-            svgstyle->setMarkerMidResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.element->document()));
+            svgstyle->setMarkerMidResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.document()));
             break;
         }
@@ -393 +393 @@
                 s = primitiveValue->getStringValue();
 
-            svgstyle->setMarkerEndResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.element->document()));
+            svgstyle->setMarkerEndResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.document()));
             break;
         }
@@ -430 +430 @@
                 s = primitiveValue->getStringValue();
 
-            svgstyle->setFilterResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.element->document()));
+            svgstyle->setFilterResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.document()));
             break;
         }
@@ -444 +444 @@
                 s = primitiveValue->getStringValue();
 
-            svgstyle->setMaskerResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.element->document()));
+            svgstyle->setMaskerResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.document()));
             break;
         }
@@ -458 +458 @@
                 s = primitiveValue->getStringValue();
 
-            svgstyle->setClipperResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.element->document()));
+            svgstyle->setClipperResource(SVGURIReference::fragmentIdentifierFromIRIString(s, state.document()));
             break;
         }
@@ -479 +479 @@
             HANDLE_INHERIT_AND_INITIAL(stopColor, StopColor);
             if (value->isSVGColor())
-                svgstyle->setStopColor(colorFromSVGColorCSSValue(static_cast<SVGColor*>(value), state.style->color()));
+                svgstyle->setStopColor(colorFromSVGColorCSSValue(static_cast<SVGColor*>(value), state.style()->color()));
             break;
         }
@@ -486 +486 @@
             HANDLE_INHERIT_AND_INITIAL(lightingColor, LightingColor);
             if (value->isSVGColor())
-                svgstyle->setLightingColor(colorFromSVGColorCSSValue(static_cast<SVGColor*>(value), state.style->color()));
+                svgstyle->setLightingColor(colorFromSVGColorCSSValue(static_cast<SVGColor*>(value), state.style()->color()));
             break;
         }
@@ -511 +511 @@
             HANDLE_INHERIT_AND_INITIAL(floodColor, FloodColor);
             if (value->isSVGColor())
-                svgstyle->setFloodColor(colorFromSVGColorCSSValue(static_cast<SVGColor*>(value), state.style->color()));
+                svgstyle->setFloodColor(colorFromSVGColorCSSValue(static_cast<SVGColor*>(value), state.style()->color()));
             break;
         }
@@ -551 +551 @@
         case CSSPropertyWebkitSvgShadow: {
             if (isInherit)
-                return svgstyle->setShadow(adoptPtr(state.parentStyle->svgStyle()->shadow() ? new ShadowData(*state.parentStyle->svgStyle()->shadow()) : 0));
+                return svgstyle->setShadow(adoptPtr(state.parentStyle()->svgStyle()->shadow() ? new ShadowData(*state.parentStyle()->svgStyle()->shadow()) : 0));
             if (isInitial || primitiveValue) // initial | none
                 return svgstyle->setShadow(nullptr);
@@ -566 +566 @@
                 return;
             ShadowValue* item = static_cast<ShadowValue*>(firstValue);
-            IntPoint location(item->x->computeLength<int>(state.style.get(), state.rootElementStyle),
-                item->y->computeLength<int>(state.style.get(), state.rootElementStyle));
-            int blur = item->blur ? item->blur->computeLength<int>(state.style.get(), state.rootElementStyle) : 0;
+            IntPoint location(item->x->computeLength<int>(state.style(), state.rootElementStyle()),
+                item->y->computeLength<int>(state.style(), state.rootElementStyle()));
+            int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle()) : 0;
             Color color;
             if (item->color)

trunk/Source/WebCore/css/StyleResolver.cpp

@@ -195 +195 @@
 #define HANDLE_INHERIT(prop, Prop) \
 if (isInherit) { \
-    m_state.style->set##Prop(m_state.parentStyle->prop()); \
+    m_state.style()->set##Prop(m_state.parentStyle()->prop()); \
     return; \
 }
@@ -202 +202 @@
 HANDLE_INHERIT(prop, Prop) \
 if (isInitial) { \
-    m_state.style->set##Prop(RenderStyle::initial##Prop()); \
+    m_state.style()->set##Prop(RenderStyle::initial##Prop()); \
     return; \
 }
@@ -224 +224 @@
 }
 
+
+inline StaticCSSRuleList* StyleResolver::State::ensureRuleList()
+{
+    if (!m_ruleList)
+        m_ruleList = StaticCSSRuleList::create();
+    return m_ruleList.get();
+}
+
+inline void StyleResolver::State::cacheBorderAndBackground()
+{
+    m_hasUAAppearance = m_style->hasAppearance();
+    if (m_hasUAAppearance) {
+        m_borderData = m_style->border();
+        m_backgroundData = *m_style->backgroundLayers();
+        m_backgroundColor = m_style->backgroundColor();
+    }
+}
+
+inline void StyleResolver::State::clear()
+{
+    m_element = 0;
+    m_styledElement = 0;
+    m_parentStyle = 0;
+    m_parentNode = 0;
+    m_regionForStyling = 0;
+    m_ruleList = 0;
+    m_matchedRules.clear();
+    m_pendingImageProperties.clear();
+#if ENABLE(CSS_SHADERS)
+    m_hasPendingShaders = false;
+#endif
+#if ENABLE(CSS_FILTERS) && ENABLE(SVG)
+    m_pendingSVGDocuments.clear();
+#endif
+}
 
 StyleResolver::StyleResolver(Document* document, bool matchAuthorAndUserStyles)
@@ -422 +457 @@
 {
     ASSERT(matchRequest.ruleSet);
-    ASSERT(m_state.element);
+    ASSERT(m_state.element());
 
     State& state = m_state;
-    Element* element = state.element;
-    StyledElement* styledElement = state.styledElement;
+    Element* element = state.element();
+    const StyledElement* styledElement = state.styledElement();
     const AtomicString& pseudoId = element->shadowPseudoId();
     if (!pseudoId.isEmpty()) {
@@ -466 +501 @@
 void StyleResolver::collectMatchingRulesForRegion(const MatchRequest& matchRequest, RuleRange& ruleRange)
 {
-    if (!m_state.regionForStyling)
+    if (!m_state.regionForStyling())
         return;
 
@@ -472 +507 @@
     for (unsigned i = 0; i < size; ++i) {
         const CSSSelector* regionSelector = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.at(i).selector;
-        if (checkRegionSelector(regionSelector, static_cast<Element*>(m_state.regionForStyling->node()))) {
+        if (checkRegionSelector(regionSelector, static_cast<Element*>(m_state.regionForStyling()->node()))) {
             RuleSet* regionRules = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.at(i).ruleSet.get();
             ASSERT(regionRules);
@@ -483 +518 @@
 {
     State& state = m_state;
-    if (state.matchedRules.isEmpty())
+    Vector<const RuleData*, 32>& matchedRules = state.matchedRules();
+    if (matchedRules.isEmpty())
         return;
 
     sortMatchedRules();
 
-    if (state.mode == SelectorChecker::CollectingRules) {
-        if (!state.ruleList)
-            state.ruleList = StaticCSSRuleList::create();
-        for (unsigned i = 0; i < state.matchedRules.size(); ++i)
-            state.ruleList->rules().append(state.matchedRules[i]->rule()->createCSSOMWrapper());
+    if (state.mode() == SelectorChecker::CollectingRules) {
+        for (unsigned i = 0; i < matchedRules.size(); ++i)
+            state.ensureRuleList()->rules().append(matchedRules[i]->rule()->createCSSOMWrapper());
         return;
     }
 
     // Now transfer the set of matched rules over to our list of declarations.
-    for (unsigned i = 0; i < state.matchedRules.size(); i++) {
-        if (state.style && state.matchedRules[i]->containsUncommonAttributeSelector())
-            state.style->setUnique();
-        addMatchedProperties(result, state.matchedRules[i]->rule()->properties(), state.matchedRules[i]->rule(), state.matchedRules[i]->linkMatchType(), state.matchedRules[i]->propertyWhitelistType());
+    for (unsigned i = 0; i < matchedRules.size(); i++) {
+        if (state.style() && matchedRules[i]->containsUncommonAttributeSelector())
+            state.style()->setUnique();
+        addMatchedProperties(result, matchedRules[i]->rule()->properties(), matchedRules[i]->rule(), matchedRules[i]->linkMatchType(), matchedRules[i]->propertyWhitelistType());
     }
 }
@@ -511 +545 @@
 
     // Match scoped author rules by traversing the scoped element stack (rebuild it if it got inconsistent).
-    if (m_scopeResolver->hasScopedStyles() && m_scopeResolver->ensureStackConsistency(m_state.element)) {
-        bool applyAuthorStyles = m_state.element->treeScope()->applyAuthorStyles();
+    if (m_scopeResolver->hasScopedStyles() && m_scopeResolver->ensureStackConsistency(m_state.element())) {
+        bool applyAuthorStyles = m_state.element()->treeScope()->applyAuthorStyles();
         bool documentScope = true;
         unsigned scopeSize = m_scopeResolver->stackSize();
         for (unsigned i = 0; i < scopeSize; ++i) {
-            m_state.matchedRules.clear();
+            m_state.matchedRules().clear();
             result.ranges.lastAuthorRule = result.matchedProperties.size() - 1;
 
@@ -547 +581 @@
 {
 #if ENABLE(SHADOW_DOM)
-    return m_scopeResolver && m_scopeResolver->styleSharingCandidateMatchesHostRules(m_state.element);
+    return m_scopeResolver && m_scopeResolver->styleSharingCandidateMatchesHostRules(m_state.element());
 #else
     return false;
@@ -558 +592 @@
     ASSERT(m_scopeResolver);
 
-    m_state.matchedRules.clear();
+    m_state.matchedRules().clear();
     result.ranges.lastAuthorRule = result.matchedProperties.size() - 1;
 
     Vector<RuleSet*> matchedRules;
-    m_scopeResolver->matchHostRules(m_state.element, matchedRules);
+    m_scopeResolver->matchHostRules(m_state.element(), matchedRules);
     if (matchedRules.isEmpty())
         return;
@@ -568 +602 @@
     for (unsigned i = matchedRules.size(); i > 0; --i) {
         RuleRange ruleRange = result.ranges.authorRuleRange();
-        collectMatchingRules(MatchRequest(matchedRules.at(i-1), includeEmptyRules, m_state.element), ruleRange);
+        collectMatchingRules(MatchRequest(matchedRules.at(i-1), includeEmptyRules, m_state.element()), ruleRange);
     }
     sortAndTransferMatchedRules(result);
@@ -579 +613 @@
 void StyleResolver::matchAuthorRules(MatchResult& result, bool includeEmptyRules)
 {
-    m_state.matchedRules.clear();
+    m_state.matchedRules().clear();
     result.ranges.lastAuthorRule = result.matchedProperties.size() - 1;
 
-    if (!m_state.element)
+    if (!m_state.element())
         return;
 
@@ -600 +634 @@
         return;
     
-    m_state.matchedRules.clear();
+    m_state.matchedRules().clear();
 
     result.ranges.lastUserRule = result.matchedProperties.size() - 1;
@@ -613 +647 @@
 void StyleResolver::matchUARules(MatchResult& result, RuleSet* rules)
 {
-    m_state.matchedRules.clear();
+    m_state.matchedRules().clear();
     
     result.ranges.lastUARule = result.matchedProperties.size() - 1;
@@ -630 +664 @@
     // In some cases we may end up looking up style for random elements in the middle of a recursive tree resolve.
     // Ancestor identifier filter won't be up-to-date in that case and we can't use the fast path.
-    bool canUseFastReject = m_selectorFilter.parentStackIsConsistent(state.parentNode);
+    bool canUseFastReject = m_selectorFilter.parentStackIsConsistent(state.parentNode());
 
     unsigned size = rules->size();
@@ -640 +674 @@
         StyleRule* rule = ruleData.rule();
         InspectorInstrumentationCookie cookie = InspectorInstrumentation::willMatchRule(document(), rule, this);
-        if (ruleMatches(ruleData, matchRequest.scope)) {
+        PseudoId dynamicPseudo = NOPSEUDO;
+        if (ruleMatches(ruleData, matchRequest.scope, dynamicPseudo)) {
             // If the rule has no properties to apply, then ignore it in the non-debug mode.
             const StylePropertySet* properties = rule->properties();
@@ -648 +683 @@
             }
             // FIXME: Exposing the non-standard getMatchedCSSRules API to web is the only reason this is needed.
-            if (state.sameOriginOnly && !ruleData.hasDocumentSecurityOrigin()) {
+            if (state.isSameOriginOnly() && !ruleData.hasDocumentSecurityOrigin()) {
                 InspectorInstrumentation::didMatchRule(cookie, false);
                 continue;
@@ -654 +689 @@
             // If we're matching normal rules, set a pseudo bit if
             // we really just matched a pseudo-element.
-            if (state.dynamicPseudo != NOPSEUDO && state.pseudoStyle == NOPSEUDO) {
-                if (state.mode == SelectorChecker::CollectingRules) {
+            if (dynamicPseudo != NOPSEUDO && state.pseudoStyle() == NOPSEUDO) {
+                if (state.mode() == SelectorChecker::CollectingRules) {
                     InspectorInstrumentation::didMatchRule(cookie, false);
                     continue;
                 }
-                if (state.dynamicPseudo < FIRST_INTERNAL_PSEUDOID)
-                    state.style->setHasPseudoStyle(state.dynamicPseudo);
+                if (dynamicPseudo < FIRST_INTERNAL_PSEUDOID)
+                    state.style()->setHasPseudoStyle(dynamicPseudo);
             } else {
                 // Update our first/last rule indices in the matched rules array.
@@ -668 +703 @@
 
                 // Add this rule to our list of matched rules.
-                addMatchedRule(&ruleData);
+                m_state.addMatchedRule(&ruleData);
                 InspectorInstrumentation::didMatchRule(cookie, true);
                 continue;
@@ -686 +721 @@
 void StyleResolver::sortMatchedRules()
 {
-    std::sort(m_state.matchedRules.begin(), m_state.matchedRules.end(), compareRules);
+    std::sort(m_state.matchedRules().begin(), m_state.matchedRules().end(), compareRules);
 }
 
@@ -698 +733 @@
 
     // Now check author rules, beginning first with presentational attributes mapped from HTML.
-    if (m_state.styledElement) {
-        addElementStyleProperties(result, m_state.styledElement->presentationAttributeStyle());
+    if (m_state.styledElement()) {
+        addElementStyleProperties(result, m_state.styledElement()->presentationAttributeStyle());
 
         // Now we check additional mapped declarations.
         // Tables and table cells share an additional mapped rule that must be applied
         // after all attributes, since their mapped style depends on the values of multiple attributes.
-        addElementStyleProperties(result, m_state.styledElement->additionalPresentationAttributeStyle());
-
-        if (m_state.styledElement->isHTMLElement()) {
+        addElementStyleProperties(result, m_state.styledElement()->additionalPresentationAttributeStyle());
+
+        if (m_state.styledElement()->isHTMLElement()) {
             bool isAuto;
-            TextDirection textDirection = toHTMLElement(m_state.styledElement)->directionalityIfhasDirAutoAttribute(isAuto);
+            TextDirection textDirection = toHTMLElement(m_state.styledElement())->directionalityIfhasDirAutoAttribute(isAuto);
             if (isAuto)
                 addMatchedProperties(result, textDirection == LTR ? leftToRightDeclaration() : rightToLeftDeclaration());
@@ -719 +754 @@
 
     // Now check our inline style attribute.
-    if (m_matchAuthorAndUserStyles && m_state.styledElement && m_state.styledElement->inlineStyle()) {
+    if (m_matchAuthorAndUserStyles && m_state.styledElement() && m_state.styledElement()->inlineStyle()) {
         // Inline style is immutable as long as there is no CSSOM wrapper.
         // FIXME: Media control shadow trees seem to have problems with caching.
-        bool isInlineStyleCacheable = !m_state.styledElement->inlineStyle()->isMutable() && !m_state.styledElement->isInShadowTree();
+        bool isInlineStyleCacheable = !m_state.styledElement()->inlineStyle()->isMutable() && !m_state.styledElement()->isInShadowTree();
         // FIXME: Constify.
-        addElementStyleProperties(result, m_state.styledElement->inlineStyle(), isInlineStyleCacheable);
+        addElementStyleProperties(result, m_state.styledElement()->inlineStyle(), isInlineStyleCacheable);
     }
 
 #if ENABLE(SVG)
     // Now check SMIL animation override style.
-    if (includeSMILProperties && m_matchAuthorAndUserStyles && m_state.styledElement && m_state.styledElement->isSVGElement())
-        addElementStyleProperties(result, static_cast<SVGElement*>(m_state.styledElement)->animatedSMILStyleProperties(), false /* isCacheable */);
+    if (includeSMILProperties && m_matchAuthorAndUserStyles && m_state.styledElement() && m_state.styledElement()->isSVGElement())
+        addElementStyleProperties(result, static_cast<SVGElement*>(m_state.styledElement())->animatedSMILStyleProperties(), false /* isCacheable */);
 #else
     UNUSED_PARAM(includeSMILProperties);
@@ -745 +780 @@
 }
 
+inline void StyleResolver::State::initElement(Element* e)
+{
+    m_element = e;
+    m_styledElement = e && e->isStyledElement() ? static_cast<StyledElement*>(e) : 0;
+    m_elementLinkState = e ? e->document()->visitedLinkState()->determineLinkState(e) : NotInsideLink;
+}
+
 inline void StyleResolver::initElement(Element* e)
 {
-    if (m_state.element != e) {
-        m_state.element = e;
-        m_state.styledElement = m_state.element && m_state.element->isStyledElement() ? static_cast<StyledElement*>(m_state.element) : 0;
-        m_state.elementLinkState = document()->visitedLinkState()->determineLinkState(e);
+    if (m_state.element() != e) {
+        m_state.initElement(e);
         if (e && e == e->document()->documentElement()) {
             e->document()->setDirectionSetOnDocumentElement(false);
@@ -758 +798 @@
 }
 
-inline void StyleResolver::initForStyleResolve(Element* e, RenderStyle* parentStyle, PseudoId pseudoID)
-{
-    State& state = m_state;
-    state.pseudoStyle = pseudoID;
+inline void StyleResolver::State::initForStyleResolve(Document* document, Element* e, RenderStyle* parentStyle, PseudoId pseudoId, RenderRegion* regionForStyling)
+{
+    m_pseudoStyle = pseudoId;
+    m_regionForStyling = regionForStyling;
 
     if (e) {
         NodeRenderingContext context(e);
-        state.parentNode = context.parentNodeForRenderingAndStyle();
-        state.parentStyle = context.resetStyleInheritance() ? 0 :
+        m_parentNode = context.parentNodeForRenderingAndStyle();
+        m_parentStyle = context.resetStyleInheritance() ? 0 :
             parentStyle ? parentStyle :
-            state.parentNode ? state.parentNode->renderStyle() : 0;
-        state.distributedToInsertionPoint = context.insertionPoint();
+            m_parentNode ? m_parentNode->renderStyle() : 0;
+        m_distributedToInsertionPoint = context.insertionPoint();
     } else {
-        state.parentNode = 0;
-        state.parentStyle = parentStyle;
-        state.distributedToInsertionPoint = false;
+        m_parentNode = 0;
+        m_parentStyle = parentStyle;
+        m_distributedToInsertionPoint = false;
     }
 
     Node* docElement = e ? e->document()->documentElement() : 0;
-    RenderStyle* docStyle = document()->renderStyle();
-    state.rootElementStyle = docElement && e != docElement ? docElement->renderStyle() : docStyle;
-
-    state.style = 0;
-
-    state.pendingImageProperties.clear();
-
-    state.ruleList = 0;
-
-    state.fontDirty = false;
+    RenderStyle* docStyle = document->renderStyle();
+    m_rootElementStyle = docElement && e != docElement ? docElement->renderStyle() : docStyle;
+
+    m_style = 0;
+    m_pendingImageProperties.clear();
+    m_ruleList = 0;
+    m_fontDirty = false;
 }
 
@@ -849 +886 @@
     if (!ruleSet)
         return false;
-    m_state.matchedRules.clear();
-
-    m_state.mode = SelectorChecker::SharingRules;
+    m_state.matchedRules().clear();
+
+    m_state.setMode(SelectorChecker::SharingRules);
     int firstRuleIndex = -1, lastRuleIndex = -1;
     RuleRange ruleRange(firstRuleIndex, lastRuleIndex);
     collectMatchingRules(MatchRequest(ruleSet), ruleRange);
-    m_state.mode = SelectorChecker::ResolvingStyle;
-    if (m_state.matchedRules.isEmpty())
-        return false;
-    m_state.matchedRules.clear();
+    m_state.setMode(SelectorChecker::ResolvingStyle);
+    if (m_state.matchedRules().isEmpty())
+        return false;
+    m_state.matchedRules().clear();
     return true;
 }
@@ -866 +903 @@
     const State& state = m_state;
     HTMLInputElement* thisInputElement = element->toInputElement();
-    HTMLInputElement* otherInputElement = state.element->toInputElement();
+    HTMLInputElement* otherInputElement = state.element()->toInputElement();
 
     if (!thisInputElement || !otherInputElement)
@@ -887 +924 @@
         return false;
 
-    if (element->isEnabledFormControl() != state.element->isEnabledFormControl())
-        return false;
-
-    if (element->isDefaultButtonForForm() != state.element->isDefaultButtonForForm())
-        return false;
-
-    if (state.element->document()->containsValidityStyleRules()) {
+    if (element->isEnabledFormControl() != state.element()->isEnabledFormControl())
+        return false;
+
+    if (element->isDefaultButtonForForm() != state.element()->isDefaultButtonForForm())
+        return false;
+
+    if (state.document()->containsValidityStyleRules()) {
         bool willValidate = element->willValidate();
 
-        if (willValidate != state.element->willValidate())
+        if (willValidate != state.element()->willValidate())
             return false;
 
-        if (willValidate && (element->isValidFormControlElement() != state.element->isValidFormControlElement()))
+        if (willValidate && (element->isValidFormControlElement() != state.element()->isValidFormControlElement()))
             return false;
 
-        if (element->isInRange() != state.element->isInRange())
+        if (element->isInRange() != state.element()->isInRange())
             return false;
 
-        if (element->isOutOfRange() != state.element->isOutOfRange())
+        if (element->isOutOfRange() != state.element()->isOutOfRange())
             return false;
     }
@@ -921 +958 @@
 {
     const State& state = m_state;
-    if (state.element->attributeData() == sharingCandidate->attributeData())
+    if (state.element()->attributeData() == sharingCandidate->attributeData())
         return true;
-    if (state.element->fastGetAttribute(XMLNames::langAttr) != sharingCandidate->fastGetAttribute(XMLNames::langAttr))
-        return false;
-    if (state.element->fastGetAttribute(langAttr) != sharingCandidate->fastGetAttribute(langAttr))
-        return false;
-
-    if (!state.elementAffectedByClassRules) {
+    if (state.element()->fastGetAttribute(XMLNames::langAttr) != sharingCandidate->fastGetAttribute(XMLNames::langAttr))
+        return false;
+    if (state.element()->fastGetAttribute(langAttr) != sharingCandidate->fastGetAttribute(langAttr))
+        return false;
+
+    if (!state.elementAffectedByClassRules()) {
         if (sharingCandidate->hasClass() && classNamesAffectedByRules(sharingCandidate->classNames()))
             return false;
@@ -934 +971 @@
 #if ENABLE(SVG)
         // SVG elements require a (slow!) getAttribute comparision because "class" is an animatable attribute for SVG.
-        if (state.element->isSVGElement()) {
-            if (state.element->getAttribute(classAttr) != sharingCandidate->getAttribute(classAttr))
+        if (state.element()->isSVGElement()) {
+            if (state.element()->getAttribute(classAttr) != sharingCandidate->getAttribute(classAttr))
                 return false;
         } else {
 #endif
-            if (state.element->classNames() != sharingCandidate->classNames())
+            if (state.element()->classNames() != sharingCandidate->classNames())
                 return false;
 #if ENABLE(SVG)
@@ -947 +984 @@
         return false;
 
-    if (state.styledElement->presentationAttributeStyle() != sharingCandidate->presentationAttributeStyle())
+    if (state.styledElement()->presentationAttributeStyle() != sharingCandidate->presentationAttributeStyle())
         return false;
 
 #if ENABLE(PROGRESS_ELEMENT)
-    if (state.element->hasTagName(progressTag)) {
-        if (static_cast<HTMLProgressElement*>(state.element)->isDeterminate() != static_cast<HTMLProgressElement*>(sharingCandidate)->isDeterminate())
+    if (state.element()->hasTagName(progressTag)) {
+        if (static_cast<HTMLProgressElement*>(state.element())->isDeterminate() != static_cast<HTMLProgressElement*>(sharingCandidate)->isDeterminate())
             return false;
     }
@@ -969 +1006 @@
     if (style->unique())
         return false;
-    if (element->tagQName() != state.element->tagQName())
+    if (element->tagQName() != state.element()->tagQName())
         return false;
     if (element->inlineStyle())
@@ -979 +1016 @@
         return false;
 #endif
-    if (element->isLink() != state.element->isLink())
-        return false;
-    if (element->hovered() != state.element->hovered())
-        return false;
-    if (element->active() != state.element->active())
-        return false;
-    if (element->focused() != state.element->focused())
-        return false;
-    if (element->shadowPseudoId() != state.element->shadowPseudoId())
+    if (element->isLink() != state.element()->isLink())
+        return false;
+    if (element->hovered() != state.element()->hovered())
+        return false;
+    if (element->active() != state.element()->active())
+        return false;
+    if (element->focused() != state.element()->focused())
+        return false;
+    if (element->shadowPseudoId() != state.element()->shadowPseudoId())
         return false;
     if (element == element->document()->cssTarget())
@@ -993 +1030 @@
     if (!sharingCandidateHasIdenticalStyleAffectingAttributes(element))
         return false;
-    if (element->additionalPresentationAttributeStyle() != state.styledElement->additionalPresentationAttributeStyle())
+    if (element->additionalPresentationAttributeStyle() != state.styledElement()->additionalPresentationAttributeStyle())
         return false;
 
@@ -1009 +1046 @@
     bool isControl = element->isFormControlElement();
 
-    if (isControl != state.element->isFormControlElement())
+    if (isControl != state.element()->isFormControlElement())
         return false;
 
@@ -1033 +1070 @@
         return false;
 
-    if (element->isLink() && state.elementLinkState != style->insideLink())
+    if (element->isLink() && state.elementLinkState() != style->insideLink())
         return false;
 
 #if ENABLE(VIDEO_TRACK)
     // Deny sharing styles between WebVTT and non-WebVTT nodes.
-    if (element->isWebVTTElement() != state.element->isWebVTTElement())
-        return false;
-
-    if (element->isWebVTTElement() && state.element->isWebVTTElement() && toWebVTTElement(element)->isPastNode() != toWebVTTElement(state.element)->isPastNode())
+    if (element->isWebVTTElement() != state.element()->isWebVTTElement())
+        return false;
+
+    if (element->isWebVTTElement() && state.element()->isWebVTTElement() && toWebVTTElement(element)->isPastNode() != toWebVTTElement(state.element())->isPastNode())
         return false;
 #endif
 
 #if ENABLE(FULLSCREEN_API)
-    if (element == element->document()->webkitCurrentFullScreenElement() || state.element == state.element->document()->webkitCurrentFullScreenElement())
+    if (element == element->document()->webkitCurrentFullScreenElement() || state.element() == state.document()->webkitCurrentFullScreenElement())
         return false;
 #endif
@@ -1068 +1105 @@
 {
     State& state = m_state;
-    if (!state.styledElement || !state.parentStyle)
+    if (!state.styledElement() || !state.parentStyle())
         return 0;
 
     // If the element has inline style it is probably unique.
-    if (state.styledElement->inlineStyle())
+    if (state.styledElement()->inlineStyle())
         return 0;
 #if ENABLE(SVG)
-    if (state.styledElement->isSVGElement() && static_cast<SVGElement*>(state.styledElement)->animatedSMILStyleProperties())
+    if (state.styledElement()->isSVGElement() && static_cast<SVGElement*>(state.styledElement())->animatedSMILStyleProperties())
         return 0;
 #endif
     // Ids stop style sharing if they show up in the stylesheets.
-    if (state.styledElement->hasID() && m_ruleSets.features().idsInRules.contains(state.styledElement->idForStyleResolution().impl()))
+    if (state.styledElement()->hasID() && m_ruleSets.features().idsInRules.contains(state.styledElement()->idForStyleResolution().impl()))
         return 0;
-    if (parentElementPreventsSharing(state.element->parentElement()))
+    if (parentElementPreventsSharing(state.element()->parentElement()))
         return 0;
-    if (state.styledElement->hasScopedHTMLStyleChild())
+    if (state.styledElement()->hasScopedHTMLStyleChild())
         return 0;
-    if (state.element == state.element->document()->cssTarget())
+    if (state.element() == state.document()->cssTarget())
         return 0;
-    if (elementHasDirectionAuto(state.element))
+    if (elementHasDirectionAuto(state.element()))
         return 0;
 
     // Cache whether state.element is affected by any known class selectors.
     // FIXME: This shouldn't be a member variable. The style sharing code could be factored out of StyleResolver.
-    state.elementAffectedByClassRules = state.element && state.element->hasClass() && classNamesAffectedByRules(state.element->classNames());
+    state.setElementAffectedByClassRules(state.element() && state.element()->hasClass() && classNamesAffectedByRules(state.element()->classNames()));
 
     // Check previous siblings and their cousins.
@@ -1098 +1135 @@
     unsigned visitedNodeCount = 0;
     StyledElement* shareElement = 0;
-    Node* cousinList = state.styledElement->previousSibling();
+    Node* cousinList = state.styledElement()->previousSibling();
     while (cousinList) {
         shareElement = findSiblingForStyleSharing(cousinList, count);
@@ -1120 +1157 @@
         return 0;
     // Tracking child index requires unique style for each node. This may get set by the sibling rule match above.
-    if (parentElementPreventsSharing(state.element->parentElement()))
+    if (parentElementPreventsSharing(state.element()->parentElement()))
         return 0;
     return shareElement->renderStyle();
@@ -1342 +1379 @@
     State& state = m_state;
     initElement(element);
-    initForStyleResolve(element, defaultParent);
-    state.regionForStyling = regionForStyling;
-    if (sharingBehavior == AllowStyleSharing && !state.distributedToInsertionPoint) {
+    state.initForStyleResolve(document(), element, defaultParent, NOPSEUDO, regionForStyling);
+    if (sharingBehavior == AllowStyleSharing && !state.distributedToInsertionPoint()) {
         RenderStyle* sharedStyle = locateSharedStyle();
         if (sharedStyle)
@@ -1352 +1388 @@
     RefPtr<RenderStyle> cloneForParent;
 
-    if (state.parentStyle) {
-        state.style = RenderStyle::create();
-        state.style->inheritFrom(state.parentStyle, isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
+    if (state.parentStyle()) {
+        state.setStyle(RenderStyle::create());
+        state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
     } else {
-        state.style = defaultStyleForElement();
-        cloneForParent = RenderStyle::clone(state.style.get());
-        state.parentStyle = cloneForParent.get();
+        state.setStyle(defaultStyleForElement());
+        cloneForParent = RenderStyle::clone(state.style());
+        state.setParentStyle(cloneForParent.get());
     }
     // contenteditable attribute (implemented by -webkit-user-modify) should
     // be propagated from shadow host to distributed node.
-    if (state.distributedToInsertionPoint) {
+    if (state.distributedToInsertionPoint()) {
         if (Element* parent = element->parentElement()) {
             if (RenderStyle* styleOfShadowHost = parent->renderStyle())
-                state.style->setUserModify(styleOfShadowHost->userModify());
+                state.style()->setUserModify(styleOfShadowHost->userModify());
         }
     }
 
     if (element->isLink()) {
-        state.style->setIsLink(true);
-        EInsideLink linkState = state.elementLinkState;
+        state.style()->setIsLink(true);
+        EInsideLink linkState = state.elementLinkState();
         if (linkState != NotInsideLink) {
             bool forceVisited = InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoVisited);
@@ -1377 +1413 @@
                 linkState = InsideVisitedLink;
         }
-        state.style->setInsideLink(linkState);
+        state.style()->setInsideLink(linkState);
     }
 
@@ -1394 +1430 @@
 
     // Clean up our style object's display and text decorations (among other fixups).
-    adjustRenderStyle(state.style.get(), state.parentStyle, element);
-
-    initElement(0); // Clear out for the next resolve.
-
-    if (cloneForParent)
-        state.parentStyle = 0;
+    adjustRenderStyle(state.style(), state.parentStyle(), element);
+
+    state.clear(); // Clear out for the next resolve.
 
     document()->didAccessStyleResolver();
 
     // Now return the style.
-    return state.style.release();
+    return state.takeStyle();
 }
 
@@ -1413 +1446 @@
         addMatchedProperties(result, keyframe->properties());
 
-    ASSERT(!m_state.style);
+    ASSERT(!m_state.style());
 
     State& state = m_state;
 
     // Create the style
-    state.style = RenderStyle::clone(elementStyle);
-
-    state.lineHeightValue = 0;
+    state.setStyle(RenderStyle::clone(elementStyle));
+    state.setLineHeightValue(0);
 
     // We don't need to bother with !important. Since there is only ever one
@@ -1432 +1464 @@
 
     // Line-height is set when we are sure we decided on the font-size
-    if (state.lineHeightValue)
-        applyProperty(CSSPropertyLineHeight, state.lineHeightValue);
+    if (state.lineHeightValue())
+        applyProperty(CSSPropertyLineHeight, state.lineHeightValue());
 
     // Now do rest of the properties.
@@ -1460 +1492 @@
     document()->didAccessStyleResolver();
 
-    return state.style.release();
+    return state.takeStyle();
 }
 
@@ -1484 +1516 @@
         // Apply the declaration to the style. This is a simplified version of the logic in styleForElement
         initElement(e);
-        initForStyleResolve(e);
+        m_state.initForStyleResolve(document(), e);
 
         const StyleKeyframe* keyframe = keyframes[i].get();
@@ -1528 +1560 @@
 PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(PseudoId pseudo, Element* e, RenderStyle* parentStyle)
 {
-    ASSERT(m_state.parentStyle);
+    ASSERT(parentStyle);
     if (!e)
         return 0;
@@ -1536 +1568 @@
     initElement(e);
 
-    initForStyleResolve(e, parentStyle, pseudo);
-    state.style = RenderStyle::create();
-    state.style->inheritFrom(m_state.parentStyle);
+    state.initForStyleResolve(document(), e, parentStyle, pseudo);
+    state.setStyle(RenderStyle::create());
+    state.style()->inheritFrom(m_state.parentStyle());
 
     // Since we don't use pseudo-elements in any of our quirk/print user agent rules, don't waste time walking
@@ -1555 +1587 @@
         return 0;
 
-    state.style->setStyleType(pseudo);
+    state.style()->setStyleType(pseudo);
 
     applyMatchedProperties(matchResult, e);
 
     // Clean up our style object's display and text decorations (among other fixups).
-    adjustRenderStyle(state.style.get(), m_state.parentStyle, 0);
+    adjustRenderStyle(state.style(), m_state.parentStyle(), 0);
 
     // Start loading resources referenced by this style.
@@ -1568 +1600 @@
 
     // Now return the style.
-    return state.style.release();
+    return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
 {
-    initForStyleResolve(document()->documentElement()); // m_rootElementStyle will be set to the document style.
-
-    m_state.style = RenderStyle::create();
-    m_state.style->inheritFrom(m_state.rootElementStyle);
+    m_state.initForStyleResolve(document(), document()->documentElement()); // m_rootElementStyle will be set to the document style.
+
+    m_state.setStyle(RenderStyle::create());
+    m_state.style()->inheritFrom(m_state.rootElementStyle());
 
     const bool isLeft = isLeftPage(pageIndex);
@@ -1587 +1619 @@
     // Only consider the global author RuleSet for @page rules, as per the HTML5 spec.
     matchPageRules(result, m_ruleSets.authorStyle(), isLeft, isFirst, page);
-    m_state.lineHeightValue = 0;
+    m_state.setLineHeightValue(0);
     bool inheritedOnly = false;
 #if ENABLE(CSS_VARIABLES)
@@ -1598 +1630 @@
 
     // Line-height is set when we are sure we decided on the font-size.
-    if (m_state.lineHeightValue)
-        applyProperty(CSSPropertyLineHeight, m_state.lineHeightValue);
+    if (m_state.lineHeightValue())
+        applyProperty(CSSPropertyLineHeight, m_state.lineHeightValue());
 
     applyMatchedProperties<LowPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
@@ -1609 +1641 @@
 
     // Now return the style.
-    return m_state.style.release();
+    return m_state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::defaultStyleForElement()
 {
-    m_state.style = RenderStyle::create();
+    m_state.setStyle(RenderStyle::create());
     // Make sure our fonts are initialized if we don't inherit them from our parent style.
     if (Settings* settings = documentSettings()) {
         initializeFontStyle(settings);
-        m_state.style->font().update(fontSelector());
+        m_state.style()->font().update(fontSelector());
     } else
-        m_state.style->font().update(0);
-
-    return m_state.style.release();
+        m_state.style()->font().update(0);
+
+    return m_state.takeStyle();
 }
 
@@ -1910 +1942 @@
     // Let the theme also have a crack at adjusting the style.
     if (style->hasAppearance())
-        RenderTheme::defaultTheme()->adjustStyle(this, style, e, m_state.hasUAAppearance, m_state.borderData, m_state.backgroundData, m_state.backgroundColor);
+        RenderTheme::defaultTheme()->adjustStyle(this, style, e, m_state.hasUAAppearance(), m_state.borderData(), m_state.backgroundData(), m_state.backgroundColor());
 
     // If we have first-letter pseudo style, do not share this style.
@@ -1993 +2025 @@
 void StyleResolver::updateFont()
 {
-    if (!m_state.fontDirty)
+    if (!m_state.fontDirty())
         return;
 
     checkForTextSizeAdjust();
-    RenderStyle* style = m_state.style.get();
-    checkForGenericFamilyChange(style, m_state.parentStyle);
-    checkForZoomChange(style, m_state.parentStyle);
+    RenderStyle* style = m_state.style();
+    checkForGenericFamilyChange(style, m_state.parentStyle());
+    checkForZoomChange(style, m_state.parentStyle());
     checkForOrientationChange(style);
-    m_state.style->font().update(m_fontSelector);
-    m_state.fontDirty = false;
-}
-
-void StyleResolver::cacheBorderAndBackground()
-{
-    m_state.hasUAAppearance = m_state.style->hasAppearance();
-    if (m_state.hasUAAppearance) {
-        m_state.borderData = m_state.style->border();
-        m_state.backgroundData = *m_state.style->backgroundLayers();
-        m_state.backgroundColor = m_state.style->backgroundColor();
-    }
+    style->font().update(m_fontSelector);
+    m_state.setFontDirty(false);
 }
 
@@ -2025 +2047 @@
         return 0;
 
-    m_state.mode = SelectorChecker::CollectingRules;
+    m_state.setMode(SelectorChecker::CollectingRules);
 
     initElement(e);
-    initForStyleResolve(e, 0, pseudoId);
+    m_state.initForStyleResolve(document(), e, 0, pseudoId);
 
     MatchResult dummy;
@@ -2041 +2063 @@
 
     if (m_matchAuthorAndUserStyles && (rulesToInclude & AuthorCSSRules)) {
-        m_state.sameOriginOnly = !(rulesToInclude & CrossOriginCSSRules);
+        m_state.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
 
         // Check the rules in author sheets.
         matchAuthorRules(dummy, rulesToInclude & EmptyCSSRules);
 
-        m_state.sameOriginOnly = false;
-    }
-
-    m_state.mode = SelectorChecker::ResolvingStyle;
-
-    return m_state.ruleList.release();
-}
-
-inline bool StyleResolver::ruleMatches(const RuleData& ruleData, const ContainerNode* scope)
+        m_state.setSameOriginOnly(false);
+    }
+
+    m_state.setMode(SelectorChecker::ResolvingStyle);
+
+    return m_state.takeRuleList();
+}
+
+inline bool StyleResolver::ruleMatches(const RuleData& ruleData, const ContainerNode* scope, PseudoId& dynamicPseudo)
 {
     State& state = m_state;
-    state.dynamicPseudo = NOPSEUDO;
 
     if (ruleData.hasFastCheckableSelector()) {
         // We know this selector does not include any pseudo elements.
-        if (state.pseudoStyle != NOPSEUDO)
+        if (state.pseudoStyle() != NOPSEUDO)
             return false;
         // We know a sufficiently simple single part selector matches simply because we found it from the rule hash.
         // This is limited to HTML only so we don't need to check the namespace.
-        if (ruleData.hasRightmostSelectorMatchingHTMLBasedOnRuleHash() && state.element->isHTMLElement()) {
+        if (ruleData.hasRightmostSelectorMatchingHTMLBasedOnRuleHash() && state.element()->isHTMLElement()) {
             if (!ruleData.hasMultipartSelector())
                 return true;
         }
-        if (ruleData.selector()->m_match == CSSSelector::Tag && !SelectorChecker::tagMatches(state.element, ruleData.selector()->tagQName()))
+        if (ruleData.selector()->m_match == CSSSelector::Tag && !SelectorChecker::tagMatches(state.element(), ruleData.selector()->tagQName()))
             return false;
-        if (!SelectorChecker::fastCheckRightmostAttributeSelector(state.element, ruleData.selector()))
+        if (!SelectorChecker::fastCheckRightmostAttributeSelector(state.element(), ruleData.selector()))
             return false;
 
-        return SelectorChecker::fastCheck(ruleData.selector(), state.element);
+        return SelectorChecker::fastCheck(ruleData.selector(), state.element());
     }
 
     // Slow path.
-    SelectorChecker selectorChecker(document(), state.mode);
-    SelectorChecker::SelectorCheckingContext context(ruleData.selector(), state.element, SelectorChecker::VisitedMatchEnabled);
-    context.elementStyle = state.style.get();
+    SelectorChecker selectorChecker(document(), state.mode());
+    SelectorChecker::SelectorCheckingContext context(ruleData.selector(), state.element(), SelectorChecker::VisitedMatchEnabled);
+    context.elementStyle = state.style();
     context.scope = scope;
-    context.pseudoStyle = state.pseudoStyle;
-    SelectorChecker::Match match = selectorChecker.match(context, state.dynamicPseudo, DOMSiblingTraversalStrategy());
+    context.pseudoStyle = state.pseudoStyle();
+    SelectorChecker::Match match = selectorChecker.match(context, dynamicPseudo, DOMSiblingTraversalStrategy());
     if (match != SelectorChecker::SelectorMatches)
         return false;
-    if (state.pseudoStyle != NOPSEUDO && state.pseudoStyle != state.dynamicPseudo)
+    if (state.pseudoStyle() != NOPSEUDO && state.pseudoStyle() != dynamicPseudo)
         return false;
     return true;
@@ -2096 +2117 @@
         return false;
 
-    m_state.pseudoStyle = NOPSEUDO;
-
-    SelectorChecker selectorChecker(document(), SelectorChecker::ResolvingStyle);
+    SelectorChecker selectorChecker(document(), m_state.mode());
     for (const CSSSelector* s = regionSelector; s; s = CSSSelectorList::next(s))
         if (selectorChecker.matches(s, regionElement))
@@ -2122 +2141 @@
 void StyleResolver::applyProperties(const StylePropertySet* properties, StyleRule* rule, bool isImportant, bool inheritedOnly, PropertyWhitelistType propertyWhitelistType)
 {
-    ASSERT((propertyWhitelistType != PropertyWhitelistRegion) || m_state.regionForStyling);
+    ASSERT((propertyWhitelistType != PropertyWhitelistRegion) || m_state.regionForStyling());
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willProcessRule(document(), rule, this);
 
@@ -2166 +2185 @@
             // we apply line-height later
             else if (property == CSSPropertyLineHeight)
-                m_state.lineHeightValue = current.value();
+                m_state.setLineHeightValue(current.value());
             break;
         case LowPriorityProperties:
@@ -2183 +2202 @@
 
     State& state = m_state;
-    if (state.style->insideLink() != NotInsideLink) {
+    if (state.style()->insideLink() != NotInsideLink) {
         for (int i = startIndex; i <= endIndex; ++i) {
             const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
             unsigned linkMatchType = matchedProperties.linkMatchType;
             // FIXME: It would be nicer to pass these as arguments but that requires changes in many places.
-            state.applyPropertyToRegularStyle = linkMatchType & SelectorChecker::MatchLink;
-            state.applyPropertyToVisitedLinkStyle = linkMatchType & SelectorChecker::MatchVisited;
+            state.setApplyPropertyToRegularStyle(linkMatchType & SelectorChecker::MatchLink);
+            state.setApplyPropertyToVisitedLinkStyle(linkMatchType & SelectorChecker::MatchVisited);
 
             applyProperties<pass>(matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, static_cast<PropertyWhitelistType>(matchedProperties.whitelistType));
         }
-        state.applyPropertyToRegularStyle = true;
-        state.applyPropertyToVisitedLinkStyle = false;
+        state.setApplyPropertyToRegularStyle(true);
+        state.setApplyPropertyToVisitedLinkStyle(false);
         return;
     }
@@ -2310 +2329 @@
         // style declarations. We then only need to apply the inherited properties, if any, as their values can depend on the 
         // element context. This is fast and saves memory by reusing the style data structures.
-        state.style->copyNonInheritedFrom(cacheItem->renderStyle.get());
-        if (state.parentStyle->inheritedDataShared(cacheItem->parentRenderStyle.get()) && !isAtShadowBoundary(element)) {
-            EInsideLink linkStatus = state.style->insideLink();
+        state.style()->copyNonInheritedFrom(cacheItem->renderStyle.get());
+        if (state.parentStyle()->inheritedDataShared(cacheItem->parentRenderStyle.get()) && !isAtShadowBoundary(element)) {
+            EInsideLink linkStatus = state.style()->insideLink();
             // If the cache item parent style has identical inherited properties to the current parent style then the
             // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
-            state.style->inheritFrom(cacheItem->renderStyle.get());
+            state.style()->inheritFrom(cacheItem->renderStyle.get());
 
             // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
-            state.style->setInsideLink(linkStatus);
+            state.style()->setInsideLink(linkStatus);
             return;
         }
@@ -2336 +2355 @@
     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
     // and (4) normal important.
-    state.lineHeightValue = 0;
+    state.setLineHeightValue(0);
     applyMatchedProperties<HighPriorityProperties>(matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     applyMatchedProperties<HighPriorityProperties>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
@@ -2342 +2361 @@
     applyMatchedProperties<HighPriorityProperties>(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
-    if (cacheItem && cacheItem->renderStyle->effectiveZoom() != state.style->effectiveZoom()) {
-        state.fontDirty = true;
+    if (cacheItem && cacheItem->renderStyle->effectiveZoom() != state.style()->effectiveZoom()) {
+        state.setFontDirty(true);
         applyInheritedOnly = false;
     }
@@ -2351 +2370 @@
 
     // Line-height is set when we are sure we decided on the font-size.
-    if (state.lineHeightValue)
-        applyProperty(CSSPropertyLineHeight, state.lineHeightValue);
+    if (state.lineHeightValue())
+        applyProperty(CSSPropertyLineHeight, state.lineHeightValue());
 
     // Many properties depend on the font. If it changes we just apply all properties.
-    if (cacheItem && cacheItem->renderStyle->fontDescription() != state.style->fontDescription())
+    if (cacheItem && cacheItem->renderStyle->fontDescription() != state.style()->fontDescription())
         applyInheritedOnly = false;
 
@@ -2362 +2381 @@
     
     // Cache our border and background so that we can examine them later.
-    cacheBorderAndBackground();
+    state.cacheBorderAndBackground();
     
     // Now do the author and user normal priority properties and all the !important properties.
@@ -2373 +2392 @@
     loadPendingResources();
     
-    ASSERT(!state.fontDirty);
+    ASSERT(!state.fontDirty());
     
     if (cacheItem || !cacheHash)
         return;
-    if (!isCacheableInMatchedPropertiesCache(state.element, state.style.get(), state.parentStyle))
-        return;
-    addToMatchedPropertiesCache(state.style.get(), state.parentStyle, cacheHash, matchResult);
+    if (!isCacheableInMatchedPropertiesCache(state.element(), state.style(), state.parentStyle()))
+        return;
+    addToMatchedPropertiesCache(state.style(), state.parentStyle(), cacheHash, matchResult);
 }
 
@@ -2444 +2463 @@
 {
     bool isFirstPageLeft = false;
-    if (!m_state.rootElementStyle->isLeftToRightDirection())
+    if (!m_state.rootElementStyle()->isLeftToRightDirection())
         isFirstPageLeft = true;
 
@@ -2465 +2484 @@
 {
     initElement(0);
-    initForStyleResolve(0, style);
-    m_state.style = style;
+    m_state.initForStyleResolve(document(), 0, style);
+    m_state.setStyle(style);
     applyPropertyToCurrentStyle(id, value);
 }
@@ -2578 +2597 @@
 bool StyleResolver::useSVGZoomRules()
 {
-    return m_state.element && m_state.element->isSVGElement();
+    return m_state.element() && m_state.element()->isSVGElement();
 }
 
@@ -2593 +2612 @@
     }
 
-    workingLength = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | ViewportPercentageConversion | AutoConversion>(state.style.get(), state.rootElementStyle, state.style->effectiveZoom());
+    workingLength = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | ViewportPercentageConversion | AutoConversion>(state.style(), state.rootElementStyle(), state.style()->effectiveZoom());
     if (workingLength.isUndefined())
         return false;
@@ -2699 +2718 @@
 void StyleResolver::resolveVariables(CSSPropertyID id, CSSValue* value, Vector<std::pair<CSSPropertyID, String> >& knownExpressions)
 {
-    std::pair<CSSPropertyID, String> expression(id, value->serializeResolvingVariables(*m_state.style->variables()));
+    std::pair<CSSPropertyID, String> expression(id, value->serializeResolvingVariables(*m_state.style()->variables()));
 
     if (knownExpressions.contains(expression))
@@ -2732 +2751 @@
 
     State& state = m_state;
-    bool isInherit = state.parentNode && value->isInheritedValue();
-    bool isInitial = value->isInitialValue() || (!state.parentNode && value->isInheritedValue());
+    bool isInherit = state.parentNode() && value->isInheritedValue();
+    bool isInitial = value->isInitialValue() || (!state.parentNode() && value->isInheritedValue());
 
     ASSERT(!isInherit || !isInitial); // isInherit -> !isInitial && isInitial -> !isInherit
-    ASSERT(!isInherit || (state.parentNode && state.parentStyle)); // isInherit -> (state.parentNode && state.parentStyle)
-
-    if (!state.applyPropertyToRegularStyle && (!state.applyPropertyToVisitedLinkStyle || !isValidVisitedLinkProperty(id))) {
+    ASSERT(!isInherit || (state.parentNode() && state.parentStyle())); // isInherit -> (state.parentNode() && state.parentStyle())
+
+    if (!state.applyPropertyToRegularStyle() && (!state.applyPropertyToVisitedLinkStyle() || !isValidVisitedLinkProperty(id))) {
         // Limit the properties that can be applied to only the ones honored by :visited.
         return;
     }
 
-    if (isInherit && !state.parentStyle->hasExplicitlyInheritedProperties() && !CSSProperty::isInheritedProperty(id))
-        state.parentStyle->setHasExplicitlyInheritedProperties();
+    if (isInherit && !state.parentStyle()->hasExplicitlyInheritedProperties() && !CSSProperty::isInheritedProperty(id))
+        state.parentStyle()->setHasExplicitlyInheritedProperties();
 
 #if ENABLE(CSS_VARIABLES)
@@ -2752 +2771 @@
         ASSERT(!variable->name().isEmpty());
         ASSERT(!variable->value().isEmpty());
-        state.style->setVariable(variable->name(), variable->value());
+        state.style()->setVariable(variable->name(), variable->value());
         return;
     }
@@ -2771 +2790 @@
     CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? static_cast<CSSPrimitiveValue*>(value) : 0;
 
-    float zoomFactor = state.style->effectiveZoom();
+    float zoomFactor = state.style()->effectiveZoom();
 
     // What follows is a list that maps the CSS properties into their corresponding front-end
@@ -2785 +2804 @@
 
             if (isInitial) {
-                state.style->clearContent();
+                state.style()->clearContent();
                 return;
             }
@@ -2797 +2816 @@
                 if (item->isImageGeneratorValue()) {
                     if (item->isGradientValue())
-                        state.style->setContent(StyleGeneratedImage::create(static_cast<CSSGradientValue*>(item)->gradientWithStylesResolved(this).get()), didSet);
+                        state.style()->setContent(StyleGeneratedImage::create(static_cast<CSSGradientValue*>(item)->gradientWithStylesResolved(this).get()), didSet);
                     else
-                        state.style->setContent(StyleGeneratedImage::create(static_cast<CSSImageGeneratorValue*>(item)), didSet);
+                        state.style()->setContent(StyleGeneratedImage::create(static_cast<CSSImageGeneratorValue*>(item)), didSet);
                     didSet = true;
 #if ENABLE(CSS_IMAGE_SET)
                 } else if (item->isImageSetValue()) {
-                    state.style->setContent(setOrPendingFromValue(CSSPropertyContent, static_cast<CSSImageSetValue*>(item)), didSet);
+                    state.style()->setContent(setOrPendingFromValue(CSSPropertyContent, static_cast<CSSImageSetValue*>(item)), didSet);
                     didSet = true;
 #endif
@@ -2809 +2828 @@
 
                 if (item->isImageValue()) {
-                    state.style->setContent(cachedOrPendingFromValue(CSSPropertyContent, static_cast<CSSImageValue*>(item)), didSet);
+                    state.style()->setContent(cachedOrPendingFromValue(CSSPropertyContent, static_cast<CSSImageValue*>(item)), didSet);
                     didSet = true;
                     continue;
@@ -2820 +2839 @@
 
                 if (contentValue->isString()) {
-                    state.style->setContent(contentValue->getStringValue().impl(), didSet);
+                    state.style()->setContent(contentValue->getStringValue().impl(), didSet);
                     didSet = true;
                 } else if (contentValue->isAttr()) {
                     // FIXME: Can a namespace be specified for an attr(foo)?
-                    if (state.style->styleType() == NOPSEUDO)
-                        state.style->setUnique();
+                    if (state.style()->styleType() == NOPSEUDO)
+                        state.style()->setUnique();
                     else
-                        state.parentStyle->setUnique();
+                        state.parentStyle()->setUnique();
                     QualifiedName attr(nullAtom, contentValue->getStringValue().impl(), nullAtom);
-                    const AtomicString& value = state.element->getAttribute(attr);
-                    state.style->setContent(value.isNull() ? emptyAtom : value.impl(), didSet);
+                    const AtomicString& value = state.element()->getAttribute(attr);
+                    state.style()->setContent(value.isNull() ? emptyAtom : value.impl(), didSet);
                     didSet = true;
                     // register the fact that the attribute value affects the style
@@ -2841 +2860 @@
                         listStyleType = static_cast<EListStyleType>(listStyleIdent - CSSValueDisc);
                     OwnPtr<CounterContent> counter = adoptPtr(new CounterContent(counterValue->identifier(), listStyleType, counterValue->separator()));
-                    state.style->setContent(counter.release(), didSet);
+                    state.style()->setContent(counter.release(), didSet);
                     didSet = true;
                 } else {
                     switch (contentValue->getIdent()) {
                     case CSSValueOpenQuote:
-                        state.style->setContent(OPEN_QUOTE, didSet);
+                        state.style()->setContent(OPEN_QUOTE, didSet);
                         didSet = true;
                         break;
                     case CSSValueCloseQuote:
-                        state.style->setContent(CLOSE_QUOTE, didSet);
+                        state.style()->setContent(CLOSE_QUOTE, didSet);
                         didSet = true;
                         break;
                     case CSSValueNoOpenQuote:
-                        state.style->setContent(NO_OPEN_QUOTE, didSet);
+                        state.style()->setContent(NO_OPEN_QUOTE, didSet);
                         didSet = true;
                         break;
                     case CSSValueNoCloseQuote:
-                        state.style->setContent(NO_CLOSE_QUOTE, didSet);
+                        state.style()->setContent(NO_CLOSE_QUOTE, didSet);
                         didSet = true;
                         break;
@@ -2868 +2887 @@
             }
             if (!didSet)
-                state.style->clearContent();
+                state.style()->clearContent();
             return;
         }
     case CSSPropertyQuotes:
         if (isInherit) {
-            state.style->setQuotes(state.parentStyle->quotes());
+            state.style()->setQuotes(state.parentStyle()->quotes());
             return;
         }
         if (isInitial) {
-            state.style->setQuotes(0);
+            state.style()->setQuotes(0);
             return;
         }
@@ -2895 +2914 @@
                 quotes->addPair(std::make_pair(startQuote, endQuote));
             }
-            state.style->setQuotes(quotes);
+            state.style()->setQuotes(quotes);
             return;
         }
         if (primitiveValue) {
             if (primitiveValue->getIdent() == CSSValueNone)
-                state.style->setQuotes(QuotesData::create());
+                state.style()->setQuotes(QuotesData::create());
         }
         return;
@@ -2906 +2925 @@
         // list of strings and ids
         if (isInherit) {
-            FontDescription parentFontDescription = state.parentStyle->fontDescription();
-            FontDescription fontDescription = state.style->fontDescription();
+            FontDescription parentFontDescription = state.parentStyle()->fontDescription();
+            FontDescription fontDescription = state.style()->fontDescription();
             fontDescription.setGenericFamily(parentFontDescription.genericFamily());
             fontDescription.setFamily(parentFontDescription.firstFamily());
@@ -2917 +2936 @@
         if (isInitial) {
             FontDescription initialDesc = FontDescription();
-            FontDescription fontDescription = state.style->fontDescription();
+            FontDescription fontDescription = state.style()->fontDescription();
             // We need to adjust the size to account for the generic family change from monospace
             // to non-monospace.
@@ -2931 +2950 @@
         if (!value->isValueList())
             return;
-        FontDescription fontDescription = state.style->fontDescription();
+        FontDescription fontDescription = state.style()->fontDescription();
         FontFamily& firstFamily = fontDescription.firstFamily();
         FontFamily* currFamily = 0;
@@ -3009 +3028 @@
     case CSSPropertyBackground:
         if (isInitial) {
-            state.style->clearBackgroundLayers();
-            state.style->setBackgroundColor(Color());
+            state.style()->clearBackgroundLayers();
+            state.style()->setBackgroundColor(Color());
         } else if (isInherit) {
-            state.style->inheritBackgroundLayers(*state.parentStyle->backgroundLayers());
-            state.style->setBackgroundColor(state.parentStyle->backgroundColor());
+            state.style()->inheritBackgroundLayers(*state.parentStyle()->backgroundLayers());
+            state.style()->setBackgroundColor(state.parentStyle()->backgroundColor());
         }
         return;
     case CSSPropertyWebkitMask:
         if (isInitial)
-            state.style->clearMaskLayers();
+            state.style()->clearMaskLayers();
         else if (isInherit)
-            state.style->inheritMaskLayers(*state.parentStyle->maskLayers());
+            state.style()->inheritMaskLayers(*state.parentStyle()->maskLayers());
         return;
     case CSSPropertyFont:
         if (isInherit) {
-            FontDescription fontDescription = state.parentStyle->fontDescription();
-            state.style->setLineHeight(state.parentStyle->specifiedLineHeight());
-            state.lineHeightValue = 0;
+            FontDescription fontDescription = state.parentStyle()->fontDescription();
+            state.style()->setLineHeight(state.parentStyle()->specifiedLineHeight());
+            state.setLineHeightValue(0);
             setFontDescription(fontDescription);
         } else if (isInitial) {
@@ -3035 +3054 @@
             initializeFontStyle(settings);
         } else if (primitiveValue) {
-            state.style->setLineHeight(RenderStyle::initialLineHeight());
-            state.lineHeightValue = 0;
+            state.style()->setLineHeight(RenderStyle::initialLineHeight());
+            state.setLineHeightValue(0);
 
             FontDescription fontDescription;
@@ -3052 +3071 @@
 
                 // Handle the zoom factor.
-                fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(document(), state.style.get(), fontDescription.isAbsoluteSize(), fontDescription.specifiedSize(), useSVGZoomRules()));
+                fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(document(), state.style(), fontDescription.isAbsoluteSize(), fontDescription.specifiedSize(), useSVGZoomRules()));
                 setFontDescription(fontDescription);
             }
@@ -3070 +3089 @@
             applyProperty(CSSPropertyFontSize, font->size.get());
 
-            state.lineHeightValue = font->lineHeight.get();
+            state.setLineHeightValue(font->lineHeight.get());
 
             applyProperty(CSSPropertyFontFamily, font->family.get());
@@ -3082 +3101 @@
         if (isInherit) {
             if (id == CSSPropertyTextShadow)
-                return state.style->setTextShadow(state.parentStyle->textShadow() ? adoptPtr(new ShadowData(*state.parentStyle->textShadow())) : nullptr);
-            return state.style->setBoxShadow(state.parentStyle->boxShadow() ? adoptPtr(new ShadowData(*state.parentStyle->boxShadow())) : nullptr);
+                return state.style()->setTextShadow(state.parentStyle()->textShadow() ? adoptPtr(new ShadowData(*state.parentStyle()->textShadow())) : nullptr);
+            return state.style()->setBoxShadow(state.parentStyle()->boxShadow() ? adoptPtr(new ShadowData(*state.parentStyle()->boxShadow())) : nullptr);
         }
         if (isInitial || primitiveValue) // initial | none
-            return id == CSSPropertyTextShadow ? state.style->setTextShadow(nullptr) : state.style->setBoxShadow(nullptr);
+            return id == CSSPropertyTextShadow ? state.style()->setTextShadow(nullptr) : state.style()->setBoxShadow(nullptr);
 
         if (!value->isValueList())
@@ -3096 +3115 @@
                 continue;
             ShadowValue* item = static_cast<ShadowValue*>(currValue);
-            int x = item->x->computeLength<int>(state.style.get(), state.rootElementStyle, zoomFactor);
-            int y = item->y->computeLength<int>(state.style.get(), state.rootElementStyle, zoomFactor);
-            int blur = item->blur ? item->blur->computeLength<int>(state.style.get(), state.rootElementStyle, zoomFactor) : 0;
-            int spread = item->spread ? item->spread->computeLength<int>(state.style.get(), state.rootElementStyle, zoomFactor) : 0;
+            int x = item->x->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor);
+            int y = item->y->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor);
+            int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor) : 0;
+            int spread = item->spread ? item->spread->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor) : 0;
             ShadowStyle shadowStyle = item->style && item->style->getIdent() == CSSValueInset ? Inset : Normal;
             Color color;
             if (item->color)
                 color = colorFromPrimitiveValue(item->color.get());
-            else if (state.style)
-                color = state.style->color();
+            else if (state.style())
+                color = state.style()->color();
 
             OwnPtr<ShadowData> shadowData = adoptPtr(new ShadowData(IntPoint(x, y), blur, spread, shadowStyle, id == CSSPropertyWebkitBoxShadow, color.isValid() ? color : Color::transparent));
             if (id == CSSPropertyTextShadow)
-                state.style->setTextShadow(shadowData.release(), i.index()); // add to the list if this is not the first entry
+                state.style()->setTextShadow(shadowData.release(), i.index()); // add to the list if this is not the first entry
             else
-                state.style->setBoxShadow(shadowData.release(), i.index()); // add to the list if this is not the first entry
+                state.style()->setBoxShadow(shadowData.release(), i.index()); // add to the list if this is not the first entry
         }
         return;
@@ -3118 +3137 @@
         HANDLE_INHERIT_AND_INITIAL(boxReflect, BoxReflect)
         if (primitiveValue) {
-            state.style->setBoxReflect(RenderStyle::initialBoxReflect());
+            state.style()->setBoxReflect(RenderStyle::initialBoxReflect());
             return;
         }
@@ -3129 +3148 @@
         reflection->setDirection(*reflectValue->direction());
         if (reflectValue->offset())
-            reflection->setOffset(reflectValue->offset()->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(state.style.get(), state.rootElementStyle, zoomFactor));
+            reflection->setOffset(reflectValue->offset()->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(state.style(), state.rootElementStyle(), zoomFactor));
         NinePieceImage mask;
         mask.setMaskDefaults();
@@ -3135 +3154 @@
         reflection->setMask(mask);
 
-        state.style->setBoxReflect(reflection.release());
+        state.style()->setBoxReflect(reflection.release());
         return;
     }
@@ -3144 +3163 @@
     case CSSPropertyWebkitColumnRule:
         if (isInherit) {
-            state.style->setColumnRuleColor(state.parentStyle->columnRuleColor().isValid() ? state.parentStyle->columnRuleColor() : state.parentStyle->color());
-            state.style->setColumnRuleStyle(state.parentStyle->columnRuleStyle());
-            state.style->setColumnRuleWidth(state.parentStyle->columnRuleWidth());
+            state.style()->setColumnRuleColor(state.parentStyle()->columnRuleColor().isValid() ? state.parentStyle()->columnRuleColor() : state.parentStyle()->color());
+            state.style()->setColumnRuleStyle(state.parentStyle()->columnRuleStyle());
+            state.style()->setColumnRuleWidth(state.parentStyle()->columnRuleWidth());
         } else if (isInitial)
-            state.style->resetColumnRule();
+            state.style()->resetColumnRule();
         return;
     case CSSPropertyWebkitMarquee:
         if (!isInherit)
             return;
-        state.style->setMarqueeDirection(state.parentStyle->marqueeDirection());
-        state.style->setMarqueeIncrement(state.parentStyle->marqueeIncrement());
-        state.style->setMarqueeSpeed(state.parentStyle->marqueeSpeed());
-        state.style->setMarqueeLoopCount(state.parentStyle->marqueeLoopCount());
-        state.style->setMarqueeBehavior(state.parentStyle->marqueeBehavior());
+        state.style()->setMarqueeDirection(state.parentStyle()->marqueeDirection());
+        state.style()->setMarqueeIncrement(state.parentStyle()->marqueeIncrement());
+        state.style()->setMarqueeSpeed(state.parentStyle()->marqueeSpeed());
+        state.style()->setMarqueeLoopCount(state.parentStyle()->marqueeLoopCount());
+        state.style()->setMarqueeBehavior(state.parentStyle()->marqueeBehavior());
         return;
     case CSSPropertyWebkitMarqueeRepetition: {
@@ -3164 +3183 @@
             return;
         if (primitiveValue->getIdent() == CSSValueInfinite)
-            state.style->setMarqueeLoopCount(-1); // -1 means repeat forever.
+            state.style()->setMarqueeLoopCount(-1); // -1 means repeat forever.
         else if (primitiveValue->isNumber())
-            state.style->setMarqueeLoopCount(primitiveValue->getIntValue());
+            state.style()->setMarqueeLoopCount(primitiveValue->getIntValue());
         return;
     }
@@ -3176 +3195 @@
             switch (ident) {
             case CSSValueSlow:
-                state.style->setMarqueeSpeed(500); // 500 msec.
+                state.style()->setMarqueeSpeed(500); // 500 msec.
                 break;
             case CSSValueNormal:
-                state.style->setMarqueeSpeed(85); // 85msec. The WinIE default.
+                state.style()->setMarqueeSpeed(85); // 85msec. The WinIE default.
                 break;
             case CSSValueFast:
-                state.style->setMarqueeSpeed(10); // 10msec. Super fast.
+                state.style()->setMarqueeSpeed(10); // 10msec. Super fast.
                 break;
             }
         } else if (primitiveValue->isTime())
-            state.style->setMarqueeSpeed(primitiveValue->computeTime<int, CSSPrimitiveValue::Milliseconds>());
+            state.style()->setMarqueeSpeed(primitiveValue->computeTime<int, CSSPrimitiveValue::Milliseconds>());
         else if (primitiveValue->isNumber()) // For scrollamount support.
-            state.style->setMarqueeSpeed(primitiveValue->getIntValue());
+            state.style()->setMarqueeSpeed(primitiveValue->getIntValue());
         return;
     }
@@ -3198 +3217 @@
             switch (primitiveValue->getIdent()) {
             case CSSValueSmall:
-                state.style->setMarqueeIncrement(Length(1, Fixed)); // 1px.
+                state.style()->setMarqueeIncrement(Length(1, Fixed)); // 1px.
                 break;
             case CSSValueNormal:
-                state.style->setMarqueeIncrement(Length(6, Fixed)); // 6px. The WinIE default.
+                state.style()->setMarqueeIncrement(Length(6, Fixed)); // 6px. The WinIE default.
                 break;
             case CSSValueLarge:
-                state.style->setMarqueeIncrement(Length(36, Fixed)); // 36px.
+                state.style()->setMarqueeIncrement(Length(36, Fixed)); // 36px.
                 break;
             }
         } else {
-            Length marqueeLength = convertToIntLength(primitiveValue, state.style.get(), state.rootElementStyle);
+            Length marqueeLength = convertToIntLength(primitiveValue, state.style(), state.rootElementStyle());
             if (!marqueeLength.isUndefined())
-                state.style->setMarqueeIncrement(marqueeLength);
+                state.style()->setMarqueeIncrement(marqueeLength);
         }
         return;
@@ -3219 +3238 @@
             return;
         if (primitiveValue->getIdent() == CSSValueAuto)
-            state.style->setLocale(nullAtom);
+            state.style()->setLocale(nullAtom);
         else
-            state.style->setLocale(primitiveValue->getStringValue());
-        FontDescription fontDescription = state.style->fontDescription();
-        fontDescription.setScript(localeToScriptCodeForFontSelection(state.style->locale()));
+            state.style()->setLocale(primitiveValue->getStringValue());
+        FontDescription fontDescription = state.style()->fontDescription();
+        fontDescription.setScript(localeToScriptCodeForFontSelection(state.style()->locale()));
         setFontDescription(fontDescription);
         return;
@@ -3242 +3261 @@
 
         if (primitiveValue->getIdent() == CSSValueNone) {
-            state.style->setDashboardRegions(RenderStyle::noneDashboardRegions());
+            state.style()->setDashboardRegions(RenderStyle::noneDashboardRegions());
             return;
         }
@@ -3252 +3271 @@
         DashboardRegion* first = region;
         while (region) {
-            Length top = convertToIntLength(region->top(), state.style.get(), state.rootElementStyle);
-            Length right = convertToIntLength(region->right(), state.style.get(), state.rootElementStyle);
-            Length bottom = convertToIntLength(region->bottom(), state.style.get(), state.rootElementStyle);
-            Length left = convertToIntLength(region->left(), state.style.get(), state.rootElementStyle);
+            Length top = convertToIntLength(region->top(), state.style(), state.rootElementStyle());
+            Length right = convertToIntLength(region->right(), state.style(), state.rootElementStyle());
+            Length bottom = convertToIntLength(region->bottom(), state.style(), state.rootElementStyle());
+            Length left = convertToIntLength(region->left(), state.style(), state.rootElementStyle());
 
             if (top.isUndefined())
@@ -3267 +3286 @@
 
             if (region->m_isCircle)
-                state.style->setDashboardRegion(StyleDashboardRegion::Circle, region->m_label, top, right, bottom, left, region == first ? false : true);
+                state.style()->setDashboardRegion(StyleDashboardRegion::Circle, region->m_label, top, right, bottom, left, region == first ? false : true);
             else if (region->m_isRectangle)
-                state.style->setDashboardRegion(StyleDashboardRegion::Rectangle, region->m_label, top, right, bottom, left, region == first ? false : true);
+                state.style()->setDashboardRegion(StyleDashboardRegion::Rectangle, region->m_label, top, right, bottom, left, region == first ? false : true);
             region = region->m_next.get();
         }
 
-        state.element->document()->setHasAnnotatedRegions(true);
+        state.document()->setHasAnnotatedRegions(true);
 
         return;
@@ -3282 +3301 @@
         if (!primitiveValue || !primitiveValue->getIdent())
             return;
-        state.style->setDraggableRegionMode(primitiveValue->getIdent() == CSSValueDrag ? DraggableRegionDrag : DraggableRegionNoDrag);
-        state.element->document()->setHasAnnotatedRegions(true);
+        state.style()->setDraggableRegionMode(primitiveValue->getIdent() == CSSValueDrag ? DraggableRegionDrag : DraggableRegionNoDrag);
+        state.document()->setHasAnnotatedRegions(true);
         return;
     }
@@ -3299 +3318 @@
             else if (primitiveValue->getIdent() == CSSValueThick)
                 result *= 5;
-            width = CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS)->computeLength<float>(state.style.get(), state.rootElementStyle, zoomFactor);
+            width = CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS)->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
             break;
         }
         default:
-            width = primitiveValue->computeLength<float>(state.style.get(), state.rootElementStyle, zoomFactor);
+            width = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
             break;
         }
-        state.style->setTextStrokeWidth(width);
+        state.style()->setTextStrokeWidth(width);
         return;
     }
@@ -3312 +3331 @@
         HANDLE_INHERIT_AND_INITIAL(transform, Transform);
         TransformOperations operations;
-        createTransformOperations(value, state.style.get(), state.rootElementStyle, operations);
-        state.style->setTransform(operations);
+        createTransformOperations(value, state.style(), state.rootElementStyle(), operations);
+        state.style()->setTransform(operations);
         return;
     }
@@ -3323 +3342 @@
 
         if (primitiveValue->getIdent() == CSSValueNone) {
-            state.style->setPerspective(0);
+            state.style()->setPerspective(0);
             return;
         }
@@ -3329 +3348 @@
         float perspectiveValue;
         if (primitiveValue->isLength())
-            perspectiveValue = primitiveValue->computeLength<float>(state.style.get(), state.rootElementStyle, zoomFactor);
+            perspectiveValue = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
         else if (primitiveValue->isNumber()) {
             // For backward compatibility, treat valueless numbers as px.
-            perspectiveValue = CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX)->computeLength<float>(state.style.get(), state.rootElementStyle, zoomFactor);
+            perspectiveValue = CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX)->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);
         } else
             return;
 
         if (perspectiveValue >= 0.0f)
-            state.style->setPerspective(perspectiveValue);
+            state.style()->setPerspective(perspectiveValue);
         return;
     }
     case CSSPropertyWebkitAnimation:
         if (isInitial)
-            state.style->clearAnimations();
+            state.style()->clearAnimations();
         else if (isInherit)
-            state.style->inheritAnimations(state.parentStyle->animations());
+            state.style()->inheritAnimations(state.parentStyle()->animations());
         return;
     case CSSPropertyWebkitTransition:
         if (isInitial)
-            state.style->clearTransitions();
+            state.style()->clearTransitions();
         else if (isInherit)
-            state.style->inheritTransitions(state.parentStyle->transitions());
+            state.style()->inheritTransitions(state.parentStyle()->transitions());
         return;
 #if ENABLE(TOUCH_EVENTS)
@@ -3359 +3378 @@
 
         Color col = colorFromPrimitiveValue(primitiveValue);
-        state.style->setTapHighlightColor(col);
+        state.style()->setTapHighlightColor(col);
         return;
     }
@@ -3368 +3387 @@
         if (!primitiveValue)
             break;
-        state.style->setUseTouchOverflowScrolling(primitiveValue->getIdent() == CSSValueTouch);
+        state.style()->setUseTouchOverflowScrolling(primitiveValue->getIdent() == CSSValueTouch);
         return;
     }
@@ -3411 +3430 @@
     case CSSPropertyWebkitMaxLogicalHeight:
     {
-        CSSPropertyID newId = CSSProperty::resolveDirectionAwareProperty(id, state.style->direction(), state.style->writingMode());
+        CSSPropertyID newId = CSSProperty::resolveDirectionAwareProperty(id, state.style()->direction(), state.style()->writingMode());
         ASSERT(newId != id);
         return applyProperty(newId, value);
@@ -3446 +3465 @@
 
         // FIXME: It is not ok to modify document state while applying style.
-        if (state.element && state.element == state.element->document()->documentElement())
-            state.element->document()->setWritingModeSetOnDocumentElement(true);
+        if (state.element() && state.element() == state.document()->documentElement())
+            state.document()->setWritingModeSetOnDocumentElement(true);
         return;
     }
@@ -3463 +3482 @@
         HANDLE_INHERIT_AND_INITIAL(lineBoxContain, LineBoxContain)
         if (primitiveValue && primitiveValue->getIdent() == CSSValueNone) {
-            state.style->setLineBoxContain(LineBoxContainNone);
+            state.style()->setLineBoxContain(LineBoxContainNone);
             return;
         }
@@ -3471 +3490 @@
 
         CSSLineBoxContainValue* lineBoxContainValue = static_cast<CSSLineBoxContainValue*>(value);
-        state.style->setLineBoxContain(lineBoxContainValue->value());
+        state.style()->setLineBoxContain(lineBoxContainValue->value());
         return;
     }
@@ -3478 +3497 @@
     case CSSPropertyWebkitFontFeatureSettings: {
         if (primitiveValue && primitiveValue->getIdent() == CSSValueNormal) {
-            setFontDescription(state.style->fontDescription().makeNormalFeatureSettings());
+            setFontDescription(state.style()->fontDescription().makeNormalFeatureSettings());
             return;
         }
@@ -3485 +3504 @@
             return;
 
-        FontDescription fontDescription = state.style->fontDescription();
+        FontDescription fontDescription = state.style()->fontDescription();
         CSSValueList* list = static_cast<CSSValueList*>(value);
         RefPtr<FontFeatureSettings> settings = FontFeatureSettings::create();
@@ -3505 +3524 @@
         HANDLE_INHERIT_AND_INITIAL(filter, Filter);
         FilterOperations operations;
-        if (createFilterOperations(value, state.style.get(), state.rootElementStyle, operations))
-            state.style->setFilter(operations);
+        if (createFilterOperations(value, state.style(), state.rootElementStyle(), operations))
+            state.style()->setFilter(operations);
         return;
     }
@@ -3514 +3533 @@
         if (!createGridTrackList(value, trackSizes, state))
             return;
-        state.style->setGridColumns(trackSizes);
+        state.style()->setGridColumns(trackSizes);
         return;
     }
@@ -3521 +3540 @@
         if (!createGridTrackList(value, trackSizes, state))
             return;
-        state.style->setGridRows(trackSizes);
+        state.style()->setGridRows(trackSizes);
         return;
     }
@@ -3529 +3548 @@
         if (!createGridPosition(value, column))
             return;
-        state.style->setGridItemColumn(column);
+        state.style()->setGridItemColumn(column);
         return;
     }
@@ -3536 +3555 @@
         if (!createGridPosition(value, row))
             return;
-        state.style->setGridItemRow(row);
+        state.style()->setGridItemRow(row);
         return;
     }
@@ -3858 +3877 @@
     RefPtr<StyleImage> image = value->cachedOrPendingImage();
     if (image && image->isPendingImage())
-        m_state.pendingImageProperties.set(property, value);
+        m_state.pendingImageProperties().set(property, value);
     return image.release();
 }
@@ -3865 +3884 @@
 {
     if (value->isPending()) {
-        m_state.pendingImageProperties.set(property, value);
+        m_state.pendingImageProperties().set(property, value);
         return StylePendingImage::create(value);
     }
@@ -3876 +3895 @@
     RefPtr<StyleImage> image = value->cachedOrPendingImageSet(document());
     if (image && image->isPendingImage())
-        m_state.pendingImageProperties.set(property, value);
+        m_state.pendingImageProperties().set(property, value);
     return image.release();
 }
@@ -3885 +3904 @@
     RefPtr<StyleImage> image = value->cachedOrPendingImage(document());
     if (image && image->isPendingImage())
-        m_state.pendingImageProperties.set(property, value);
+        m_state.pendingImageProperties().set(property, value);
     return image.release();
 }
@@ -3891 +3910 @@
 void StyleResolver::checkForTextSizeAdjust()
 {
-    RenderStyle* style = m_state.style.get();
+    RenderStyle* style = m_state.style();
 
     if (style->textSizeAdjust())
@@ -3963 +3982 @@
     fontDescription.setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
     setFontSize(fontDescription, fontSizeForKeyword(document(), CSSValueMedium, false));
-    m_state.style->setLineHeight(RenderStyle::initialLineHeight());
-    m_state.lineHeightValue = 0;
+    m_state.style()->setLineHeight(RenderStyle::initialLineHeight());
+    m_state.setLineHeightValue(0);
     setFontDescription(fontDescription);
 }
@@ -3971 +3990 @@
 {
     fontDescription.setSpecifiedSize(size);
-    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(document(), m_state.style.get(), fontDescription.isAbsoluteSize(), size, useSVGZoomRules()));
+    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(document(), m_state.style(), fontDescription.isAbsoluteSize(), size, useSVGZoomRules()));
 }
 
@@ -4180 +4199 @@
         return Color();
     case CSSValueWebkitText:
-        return state.element->document()->textColor();
+        return state.document()->textColor();
     case CSSValueWebkitLink:
-        return (state.element->isLink() && forVisitedLink) ? state.element->document()->visitedLinkColor() : state.element->document()->linkColor();
+        return (state.element()->isLink() && forVisitedLink) ? state.document()->visitedLinkColor() : state.document()->linkColor();
     case CSSValueWebkitActivelink:
-        return state.element->document()->activeLinkColor();
+        return state.document()->activeLinkColor();
     case CSSValueWebkitFocusRingColor:
         return RenderTheme::focusRingColor();
     case CSSValueCurrentcolor:
-        return state.style->color();
+        return state.style()->color();
     default:
         return colorForCSSValue(ident);
@@ -4523 +4542 @@
 {
     State& state = m_state;
-    if (!state.style->hasFilter() || state.pendingSVGDocuments.isEmpty())
-        return;
-
-    CachedResourceLoader* cachedResourceLoader = state.element->document()->cachedResourceLoader();
-    Vector<RefPtr<FilterOperation> >& filterOperations = state.style->mutableFilter().operations();
+    if (!state.style()->hasFilter() || state.pendingSVGDocuments().isEmpty())
+        return;
+
+    CachedResourceLoader* cachedResourceLoader = state.document()->cachedResourceLoader();
+    Vector<RefPtr<FilterOperation> >& filterOperations = state.style()->mutableFilter().operations();
     for (unsigned i = 0; i < filterOperations.size(); ++i) {
         RefPtr<FilterOperation> filterOperation = filterOperations.at(i);
@@ -4533 +4552 @@
             ReferenceFilterOperation* referenceFilter = static_cast<ReferenceFilterOperation*>(filterOperation.get());
 
-            WebKitCSSSVGDocumentValue* value = state.pendingSVGDocuments.get(referenceFilter).get();
+            WebKitCSSSVGDocumentValue* value = state.pendingSVGDocuments().get(referenceFilter).get();
             if (!value)
                 continue;
@@ -4544 +4563 @@
         }
     }
-    state.pendingSVGDocuments.clear();
+    state.pendingSVGDocuments().clear();
 }
 #endif
@@ -4560 +4579 @@
     StyleShader* shader = value->cachedOrPendingShader();
     if (shader && shader->isPendingShader())
-        m_state.hasPendingShaders = true;
+        m_state.setHasPendingShaders(true);
     return shader;
 }
@@ -4566 +4585 @@
 void StyleResolver::loadPendingShaders()
 {
-    if (!m_state.style->hasFilter() || !m_state.hasPendingShaders)
-        return;
-
-    CachedResourceLoader* cachedResourceLoader = m_state.element->document()->cachedResourceLoader();
-
-    Vector<RefPtr<FilterOperation> >& filterOperations = m_state.style->mutableFilter().operations();
+    if (!m_state.style()->hasFilter() || !m_state.hasPendingShaders())
+        return;
+
+    CachedResourceLoader* cachedResourceLoader = m_state.document()->cachedResourceLoader();
+
+    Vector<RefPtr<FilterOperation> >& filterOperations = m_state.style()->mutableFilter().operations();
     for (unsigned i = 0; i < filterOperations.size(); ++i) {
         RefPtr<FilterOperation> filterOperation = filterOperations.at(i);
@@ -4588 +4607 @@
         }
     }
-    m_state.hasPendingShaders = false;
+    m_state.setHasPendingShaders(false);
 }
 
@@ -4630 +4649 @@
     RefPtr<CustomFilterTransformParameter> transformParameter = CustomFilterTransformParameter::create(name);
     TransformOperations operations;
-    createTransformOperations(values, m_state.style.get(), m_state.rootElementStyle, operations);
+    createTransformOperations(values, m_state.style(), m_state.rootElementStyle(), operations);
     transformParameter->setOperations(operations);
     return transformParameter.release();
@@ -4880 +4899 @@
 
             WebKitCSSSVGDocumentValue* svgDocumentValue = static_cast<WebKitCSSSVGDocumentValue*>(argument);
-            KURL url = m_state.element->document()->completeURL(svgDocumentValue->url());
+            KURL url = m_state.document()->completeURL(svgDocumentValue->url());
 
             RefPtr<ReferenceFilterOperation> operation = ReferenceFilterOperation::create(svgDocumentValue->url(), url.fragmentIdentifier(), operationType);
-            if (SVGURIReference::isExternalURIReference(svgDocumentValue->url(), m_state.element->document())) {
+            if (SVGURIReference::isExternalURIReference(svgDocumentValue->url(), m_state.document())) {
                 if (!svgDocumentValue->loadRequested())
-                    m_state.pendingSVGDocuments.set(operation.get(), svgDocumentValue);
+                    m_state.pendingSVGDocuments().set(operation.get(), svgDocumentValue);
                 else if (svgDocumentValue->cachedSVGDocument())
                     operation->setCachedSVGDocumentReference(adoptPtr(new CachedSVGDocumentReference(svgDocumentValue->cachedSVGDocument())));
@@ -4989 +5008 @@
 PassRefPtr<StyleImage> StyleResolver::loadPendingImage(StylePendingImage* pendingImage)
 {
-    CachedResourceLoader* cachedResourceLoader = m_state.element->document()->cachedResourceLoader();
+    CachedResourceLoader* cachedResourceLoader = m_state.document()->cachedResourceLoader();
 
     if (pendingImage->cssImageValue()) {
@@ -5019 +5038 @@
 void StyleResolver::loadPendingImages()
 {
-    if (m_state.pendingImageProperties.isEmpty())
-        return;
-
-    PendingImagePropertyMap::const_iterator::Keys end = m_state.pendingImageProperties.end().keys();
-    for (PendingImagePropertyMap::const_iterator::Keys it = m_state.pendingImageProperties.begin().keys(); it != end; ++it) {
+    if (m_state.pendingImageProperties().isEmpty())
+        return;
+
+    PendingImagePropertyMap::const_iterator::Keys end = m_state.pendingImageProperties().end().keys();
+    for (PendingImagePropertyMap::const_iterator::Keys it = m_state.pendingImageProperties().begin().keys(); it != end; ++it) {
         CSSPropertyID currentProperty = *it;
 
         switch (currentProperty) {
         case CSSPropertyBackgroundImage: {
-            for (FillLayer* backgroundLayer = m_state.style->accessBackgroundLayers(); backgroundLayer; backgroundLayer = backgroundLayer->next()) {
+            for (FillLayer* backgroundLayer = m_state.style()->accessBackgroundLayers(); backgroundLayer; backgroundLayer = backgroundLayer->next()) {
                 if (backgroundLayer->image() && backgroundLayer->image()->isPendingImage())
                     backgroundLayer->setImage(loadPendingImage(static_cast<StylePendingImage*>(backgroundLayer->image())));
@@ -5035 +5054 @@
         }
         case CSSPropertyContent: {
-            for (ContentData* contentData = const_cast<ContentData*>(m_state.style->contentData()); contentData; contentData = contentData->next()) {
+            for (ContentData* contentData = const_cast<ContentData*>(m_state.style()->contentData()); contentData; contentData = contentData->next()) {
                 if (contentData->isImage()) {
                     StyleImage* image = static_cast<ImageContentData*>(contentData)->image();
@@ -5048 +5067 @@
         }
         case CSSPropertyCursor: {
-            if (CursorList* cursorList = m_state.style->cursors()) {
+            if (CursorList* cursorList = m_state.style()->cursors()) {
                 for (size_t i = 0; i < cursorList->size(); ++i) {
                     CursorData& currentCursor = cursorList->at(i);
@@ -5060 +5079 @@
         }
         case CSSPropertyListStyleImage: {
-            if (m_state.style->listStyleImage() && m_state.style->listStyleImage()->isPendingImage())
-                m_state.style->setListStyleImage(loadPendingImage(static_cast<StylePendingImage*>(m_state.style->listStyleImage())));
+            if (m_state.style()->listStyleImage() && m_state.style()->listStyleImage()->isPendingImage())
+                m_state.style()->setListStyleImage(loadPendingImage(static_cast<StylePendingImage*>(m_state.style()->listStyleImage())));
             break;
         }
         case CSSPropertyBorderImageSource: {
-            if (m_state.style->borderImageSource() && m_state.style->borderImageSource()->isPendingImage())
-                m_state.style->setBorderImageSource(loadPendingImage(static_cast<StylePendingImage*>(m_state.style->borderImageSource())));
+            if (m_state.style()->borderImageSource() && m_state.style()->borderImageSource()->isPendingImage())
+                m_state.style()->setBorderImageSource(loadPendingImage(static_cast<StylePendingImage*>(m_state.style()->borderImageSource())));
             break;
         }
         case CSSPropertyWebkitBoxReflect: {
-            if (StyleReflection* reflection = m_state.style->boxReflect()) {
+            if (StyleReflection* reflection = m_state.style()->boxReflect()) {
                 const NinePieceImage& maskImage = reflection->mask();
                 if (maskImage.image() && maskImage.image()->isPendingImage()) {
@@ -5080 +5099 @@
         }
         case CSSPropertyWebkitMaskBoxImageSource: {
-            if (m_state.style->maskBoxImageSource() && m_state.style->maskBoxImageSource()->isPendingImage())
-                m_state.style->setMaskBoxImageSource(loadPendingImage(static_cast<StylePendingImage*>(m_state.style->maskBoxImageSource())));
+            if (m_state.style()->maskBoxImageSource() && m_state.style()->maskBoxImageSource()->isPendingImage())
+                m_state.style()->setMaskBoxImageSource(loadPendingImage(static_cast<StylePendingImage*>(m_state.style()->maskBoxImageSource())));
             break;
         }
         case CSSPropertyWebkitMaskImage: {
-            for (FillLayer* maskLayer = m_state.style->accessMaskLayers(); maskLayer; maskLayer = maskLayer->next()) {
+            for (FillLayer* maskLayer = m_state.style()->accessMaskLayers(); maskLayer; maskLayer = maskLayer->next()) {
                 if (maskLayer->image() && maskLayer->image()->isPendingImage())
                     maskLayer->setImage(loadPendingImage(static_cast<StylePendingImage*>(maskLayer->image())));
@@ -5096 +5115 @@
     }
 
-    m_state.pendingImageProperties.clear();
+    m_state.pendingImageProperties().clear();
 }
 

trunk/Source/WebCore/css/StyleResolver.h

@@ -166 +166 @@
     static PassRefPtr<RenderStyle> styleForDocument(Document*, CSSFontSelector* = 0);
 
-    RenderStyle* style() const { return m_state.style.get(); }
-    RenderStyle* parentStyle() const { return m_state.parentStyle; }
-    RenderStyle* rootElementStyle() const { return m_state.rootElementStyle; }
-    Element* element() const { return m_state.element; }
-    Document* document() const { return m_document; }
+    RenderStyle* style() const { return m_state.style(); }
+    RenderStyle* parentStyle() const { return m_state.parentStyle(); }
+    RenderStyle* rootElementStyle() const { return m_state.rootElementStyle(); }
+    Element* element() { return m_state.element(); }
+    Document* document() { return m_document; }
     StyleScopeResolver* scopeResolver() const { return m_scopeResolver.get(); }
-    const FontDescription& fontDescription() { return style()->fontDescription(); }
-    const FontDescription& parentFontDescription() { return parentStyle()->fontDescription(); }
-    void setFontDescription(const FontDescription& fontDescription) { m_state.fontDirty |= style()->setFontDescription(fontDescription); }
-    void setZoom(float f) { m_state.fontDirty |= style()->setZoom(f); }
-    void setEffectiveZoom(float f) { m_state.fontDirty |= style()->setEffectiveZoom(f); }
-    void setTextSizeAdjust(bool b) { m_state.fontDirty |= style()->setTextSizeAdjust(b); }
-    void setWritingMode(WritingMode writingMode) { m_state.fontDirty |= style()->setWritingMode(writingMode); }
-    void setTextOrientation(TextOrientation textOrientation) { m_state.fontDirty |= style()->setTextOrientation(textOrientation); }
-    bool hasParentNode() const { return m_state.parentNode; }
+    bool hasParentNode() const { return m_state.parentNode(); }
 
     // FIXME: It could be better to call m_ruleSets.appendAuthorStyleSheets() directly after we factor StyleRsolver further.
@@ -208 +200 @@
 
 private:
-    void initForStyleResolve(Element*, RenderStyle* parentStyle = 0, PseudoId = NOPSEUDO);
     void initElement(Element*);
     RenderStyle* locateSharedStyle();
@@ -315 +306 @@
     void adjustRenderStyle(RenderStyle* styleToAdjust, RenderStyle* parentStyle, Element*);
 
-    void addMatchedRule(const RuleData* rule) { m_state.matchedRules.append(rule); }
-
     struct RuleRange {
         RuleRange(int& firstRuleIndex, int& lastRuleIndex): firstRuleIndex(firstRuleIndex), lastRuleIndex(lastRuleIndex) { }
@@ -388 +377 @@
     void sortAndTransferMatchedRules(MatchResult&);
 
-    bool ruleMatches(const RuleData&, const ContainerNode* scope);
+    bool ruleMatches(const RuleData&, const ContainerNode* scope, PseudoId&);
     bool checkRegionSelector(const CSSSelector* regionSelector, Element* regionElement);
     void applyMatchedProperties(const MatchResult&, const Element*);
@@ -433 +422 @@
     public:
         State()
-        : element(0)
-        , styledElement(0)
-        , parentNode(0)
-        , parentStyle(0)
-        , rootElementStyle(0)
-        , regionForStyling(0)
-        , sameOriginOnly(false)
-        , pseudoStyle(NOPSEUDO)
-        , elementLinkState(NotInsideLink)
-        , distributedToInsertionPoint(false)
-        , elementAffectedByClassRules(false)
-        , mode(SelectorChecker::ResolvingStyle)
-        , applyPropertyToRegularStyle(true)
-        , applyPropertyToVisitedLinkStyle(false)
+        : m_element(0)
+        , m_styledElement(0)
+        , m_parentNode(0)
+        , m_parentStyle(0)
+        , m_rootElementStyle(0)
+        , m_regionForStyling(0)
+        , m_sameOriginOnly(false)
+        , m_pseudoStyle(NOPSEUDO)
+        , m_elementLinkState(NotInsideLink)
+        , m_distributedToInsertionPoint(false)
+        , m_elementAffectedByClassRules(false)
+        , m_mode(SelectorChecker::ResolvingStyle)
+        , m_applyPropertyToRegularStyle(true)
+        , m_applyPropertyToVisitedLinkStyle(false)
 #if ENABLE(CSS_SHADERS)
-        , hasPendingShaders(false)
-#endif
-        , lineHeightValue(0)
-        , fontDirty(false)
-        , hasUAAppearance(false)
-        , backgroundData(BackgroundFillLayer) { }
+        , m_hasPendingShaders(false)
+#endif
+        , m_lineHeightValue(0)
+        , m_fontDirty(false)
+        , m_hasUAAppearance(false)
+        , m_backgroundData(BackgroundFillLayer) { }
+
+    public:
+        void initElement(Element*);
+        void initForStyleResolve(Document*, Element*, RenderStyle* parentStyle = 0, PseudoId = NOPSEUDO, RenderRegion* regionForStyling = 0);
+        void clear();
+
+        Document* document() const { return m_element->document(); }
+        Element* element() const { return m_element; }
+        StyledElement* styledElement() const { return m_styledElement; }
+        void setStyle(PassRefPtr<RenderStyle> style) { m_style = style; }
+        RenderStyle* style() const { return m_style.get(); }
+        PassRefPtr<RenderStyle> takeStyle() { return m_style.release(); }
+
+        StaticCSSRuleList* ensureRuleList();
+        PassRefPtr<CSSRuleList> takeRuleList() { return m_ruleList.release(); }
+
+        const ContainerNode* parentNode() const { return m_parentNode; }
+        void setParentStyle(RenderStyle* parentStyle) { m_parentStyle = parentStyle; }
+        RenderStyle* parentStyle() const { return m_parentStyle; }
+        RenderStyle* rootElementStyle() const { return m_rootElementStyle; }
+
+        const RenderRegion* regionForStyling() const { return m_regionForStyling; }
+        void setSameOriginOnly(bool isSameOriginOnly) { m_sameOriginOnly = isSameOriginOnly; }
+        bool isSameOriginOnly() const { return m_sameOriginOnly; }
+        PseudoId pseudoStyle() const { return m_pseudoStyle; }
+        EInsideLink elementLinkState() const { return m_elementLinkState; }
+        bool distributedToInsertionPoint() const { return m_distributedToInsertionPoint; }
+        void setElementAffectedByClassRules(bool isAffected) { m_elementAffectedByClassRules = isAffected; }
+        bool elementAffectedByClassRules() const { return m_elementAffectedByClassRules; }
+        void setMode(SelectorChecker::Mode mode) { m_mode = mode; }
+        SelectorChecker::Mode mode() const { return m_mode; }
         
-public:
+        void setApplyPropertyToRegularStyle(bool isApply) { m_applyPropertyToRegularStyle = isApply; }
+        void setApplyPropertyToVisitedLinkStyle(bool isApply) { m_applyPropertyToVisitedLinkStyle = isApply; }
+        bool applyPropertyToRegularStyle() const { return m_applyPropertyToRegularStyle; }
+        bool applyPropertyToVisitedLinkStyle() const { return m_applyPropertyToVisitedLinkStyle; }
+        PendingImagePropertyMap& pendingImageProperties() { return m_pendingImageProperties; }
+#if ENABLE(CSS_FILTERS) && ENABLE(SVG)
+        PendingSVGDocumentMap& pendingSVGDocuments() { return m_pendingSVGDocuments; }
+#endif
+#if ENABLE(CSS_SHADERS)
+        void setHasPendingShaders(bool hasPendingShaders) { m_hasPendingShaders = hasPendingShaders; }
+        bool hasPendingShaders() const { return m_hasPendingShaders; }
+#endif
+
+        void setLineHeightValue(CSSValue* value) { m_lineHeightValue = value; }
+        CSSValue* lineHeightValue() { return m_lineHeightValue; }
+        void setFontDirty(bool isDirty) { m_fontDirty = isDirty; }
+        bool fontDirty() const { return m_fontDirty; }
+
+        void cacheBorderAndBackground();
+        bool hasUAAppearance() const { return m_hasUAAppearance; }
+        BorderData borderData() const { return m_borderData; }
+        FillLayer backgroundData() const { return m_backgroundData; }
+        Color backgroundColor() const { return m_backgroundColor; }
+
+        const FontDescription& fontDescription() { return m_style->fontDescription(); }
+        const FontDescription& parentFontDescription() { return m_parentStyle->fontDescription(); }
+        void setFontDescription(const FontDescription& fontDescription) { m_fontDirty |= m_style->setFontDescription(fontDescription); }
+        void setZoom(float f) { m_fontDirty |= m_style->setZoom(f); }
+        void setEffectiveZoom(float f) { m_fontDirty |= m_style->setEffectiveZoom(f); }
+        void setTextSizeAdjust(bool b) { m_fontDirty |= m_style->setTextSizeAdjust(b); }
+        void setWritingMode(WritingMode writingMode) { m_fontDirty |= m_style->setWritingMode(writingMode); }
+        void setTextOrientation(TextOrientation textOrientation) { m_fontDirty |= m_style->setTextOrientation(textOrientation); }
+
+        Vector<const RuleData*, 32>& matchedRules() { return m_matchedRules; }
+        void addMatchedRule(const RuleData* rule) { m_matchedRules.append(rule); }
+        
+    private:
         // FIXME(bug 108563): to make it easier to review, these member
         // variables are public. However we should add methods to access
         // these variables.
-        Element* element;
-        RefPtr<RenderStyle> style;
-        StyledElement* styledElement;
-        ContainerNode* parentNode;
-        RenderStyle* parentStyle;
-        RenderStyle* rootElementStyle;
+        Element* m_element;
+        RefPtr<RenderStyle> m_style;
+        StyledElement* m_styledElement;
+        ContainerNode* m_parentNode;
+        RenderStyle* m_parentStyle;
+        RenderStyle* m_rootElementStyle;
         
-        RenderRegion* regionForStyling;
-        bool sameOriginOnly;
-        PseudoId pseudoStyle;
-
-        EInsideLink elementLinkState;
-
-        bool distributedToInsertionPoint;
-
-        bool elementAffectedByClassRules;
-
-        PseudoId dynamicPseudo;
-
-        SelectorChecker::Mode mode;
+        RenderRegion* m_regionForStyling;
+        bool m_sameOriginOnly;
+        PseudoId m_pseudoStyle;
+
+        EInsideLink m_elementLinkState;
+
+        bool m_distributedToInsertionPoint;
+
+        bool m_elementAffectedByClassRules;
+
+        SelectorChecker::Mode m_mode;
 
         // A buffer used to hold the set of matched rules for an element,
         // and a temporary buffer used for merge sorting.
-        Vector<const RuleData*, 32> matchedRules;
-        RefPtr<StaticCSSRuleList> ruleList;
-
-        bool applyPropertyToRegularStyle;
-        bool applyPropertyToVisitedLinkStyle;
-
-        PendingImagePropertyMap pendingImageProperties;
+        Vector<const RuleData*, 32> m_matchedRules;
+        RefPtr<StaticCSSRuleList> m_ruleList;
+
+        bool m_applyPropertyToRegularStyle;
+        bool m_applyPropertyToVisitedLinkStyle;
+
+        PendingImagePropertyMap m_pendingImageProperties;
 #if ENABLE(CSS_SHADERS)
-        bool hasPendingShaders;
+        bool m_hasPendingShaders;
 #endif
 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
-        PendingSVGDocumentMap pendingSVGDocuments;
-#endif
-        CSSValue* lineHeightValue;
-        bool fontDirty;
-
-        bool hasUAAppearance;
-        BorderData borderData;
-        FillLayer backgroundData;
-        Color backgroundColor;
+        PendingSVGDocumentMap m_pendingSVGDocuments;
+#endif
+        CSSValue* m_lineHeightValue;
+        bool m_fontDirty;
+
+        bool m_hasUAAppearance;
+        BorderData m_borderData;
+        FillLayer m_backgroundData;
+        Color m_backgroundColor;
     };
 
@@ -514 +568 @@
     PassRefPtr<StyleImage> cursorOrPendingFromValue(CSSPropertyID, CSSCursorImageValue*);
 
-    bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle; }
-    bool applyPropertyToVisitedLinkStyle() const { return m_state.applyPropertyToVisitedLinkStyle; }
+    bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle(); }
+    bool applyPropertyToVisitedLinkStyle() const { return m_state.applyPropertyToVisitedLinkStyle(); }
 
     static Length convertToIntLength(CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, double multiplier = 1);
@@ -522 +576 @@
     CSSToStyleMap* styleMap() { return &m_styleMap; }
     InspectorCSSOMWrappers& inspectorCSSOMWrappers() { return m_inspectorCSSOMWrappers; }
-
+    const FontDescription& fontDescription() { return m_state.fontDescription(); }
+    const FontDescription& parentFontDescription() { return m_state.parentFontDescription(); }
+    void setFontDescription(const FontDescription& fontDescription) { m_state.setFontDescription(fontDescription); }
+    void setZoom(float f) { m_state.setZoom(f); }
+    void setEffectiveZoom(float f) { m_state.setEffectiveZoom(f); }
+    void setTextSizeAdjust(bool b) { m_state.setTextSizeAdjust(b); }
+    void setWritingMode(WritingMode writingMode) { m_state.setWritingMode(writingMode); }
+    void setTextOrientation(TextOrientation textOrientation) { m_state.setTextOrientation(textOrientation); }
+    
     void reportMemoryUsage(MemoryObjectInfo*) const;