Change StyleResolver::document() to be private

Source/core/css/resolver/StyleResolver.cpp

Index: Source/core/css/resolver/StyleResolver.cpp
diff --git a/Source/core/css/resolver/StyleResolver.cpp b/Source/core/css/resolver/StyleResolver.cpp
index eeac97f337b6c49781d02cea35a2d1cbe7670d2f..5848a8eafbf534d176381465b44837cc57744724 100644
--- a/Source/core/css/resolver/StyleResolver.cpp
+++ b/Source/core/css/resolver/StyleResolver.cpp
@@ -187,12 +187,12 @@ void StyleResolver::appendCSSStyleSheet(CSSStyleSheet* cssSheet)
     if (cssSheet->mediaQueries() && !m_medium->eval(cssSheet->mediaQueries(), &m_viewportDependentMediaQueryResults))
         return;
 
-    TreeScope* treeScope = ScopedStyleResolver::treeScopeFor(document(), cssSheet);
+    TreeScope* treeScope = ScopedStyleResolver::treeScopeFor(*m_document, cssSheet);

[rune, 2014/09/24 08:16:20]

Why not keep document() and make it private instead? I think the current code
looks prettier.

     if (!treeScope)
         return;
 
     ScopedStyleResolver& resolver = treeScope->ensureScopedStyleResolver();
-    document().styleEngine()->addScopedStyleResolver(&resolver);
+    m_document->styleEngine()->addScopedStyleResolver(&resolver);
     resolver.addRulesFromSheet(cssSheet, *m_medium, this);
 }
 
@@ -218,12 +218,12 @@ void StyleResolver::finishAppendAuthorStyleSheets()
 {
     collectFeatures();
 
-    if (document().renderView() && document().renderView()->style())
-        document().renderView()->style()->font().update(document().styleEngine()->fontSelector());
+    if (m_document->renderView() && m_document->renderView()->style())
+        m_document->renderView()->style()->font().update(m_document->styleEngine()->fontSelector());
 
     collectViewportRules();
 
-    document().styleEngine()->resetCSSFeatureFlags(m_features);
+    m_document->styleEngine()->resetCSSFeatureFlags(m_features);
 }
 
 void StyleResolver::resetRuleFeatures()
@@ -239,7 +239,7 @@ void StyleResolver::processScopedRules(const RuleSet& authorRules, CSSStyleSheet
 {
     const WillBeHeapVector<RawPtrWillBeMember<StyleRuleKeyframes> > keyframesRules = authorRules.keyframesRules();
     ScopedStyleResolver* resolver = &scope.treeScope().ensureScopedStyleResolver();
-    document().styleEngine()->addScopedStyleResolver(resolver);
+    m_document->styleEngine()->addScopedStyleResolver(resolver);
     for (unsigned i = 0; i < keyframesRules.size(); ++i)
         resolver->addKeyframeStyle(keyframesRules[i]);
 
@@ -249,7 +249,7 @@ void StyleResolver::processScopedRules(const RuleSet& authorRules, CSSStyleSheet
     if (scope.isDocumentNode()) {
         const WillBeHeapVector<RawPtrWillBeMember<StyleRuleFontFace> > fontFaceRules = authorRules.fontFaceRules();
         for (unsigned i = 0; i < fontFaceRules.size(); ++i)
-            addFontFaceRule(m_document, document().styleEngine()->fontSelector(), fontFaceRules[i]);
+            addFontFaceRule(m_document, m_document->styleEngine()->fontSelector(), fontFaceRules[i]);
         if (fontFaceRules.size())
             invalidateMatchedPropertiesCache();
     }
@@ -269,7 +269,7 @@ void StyleResolver::resetAuthorStyle(TreeScope& treeScope)
         return;
 
     // resolver is going to be freed below.
-    document().styleEngine()->removeScopedStyleResolver(resolver);
+    m_document->styleEngine()->removeScopedStyleResolver(resolver);
     treeScope.clearScopedStyleResolver();
 }
 
@@ -294,10 +294,10 @@ void StyleResolver::collectFeatures()
     if (defaultStyleSheets.defaultStyle())
         m_features.add(defaultStyleSheets.defaultStyle()->features());
 
-    if (document().isViewSource())
+    if (m_document->isViewSource())
         m_features.add(defaultStyleSheets.defaultViewSourceStyle()->features());
 
-    if (document().isTransitionDocument())
+    if (m_document->isTransitionDocument())
         m_features.add(defaultStyleSheets.defaultTransitionStyle()->features());
 
     if (m_watchedSelectorsRules)
@@ -305,7 +305,7 @@ void StyleResolver::collectFeatures()
 
     m_treeBoundaryCrossingRules.collectFeaturesTo(m_features);
 
-    document().styleEngine()->collectScopedStyleFeaturesTo(m_features);
+    m_document->styleEngine()->collectScopedStyleFeaturesTo(m_features);
 
     m_siblingRuleSet = makeRuleSet(m_features.siblingRules);
     m_uncommonAttributeRuleSet = makeRuleSet(m_features.uncommonAttributeRules);
@@ -321,7 +321,7 @@ void StyleResolver::addToStyleSharingList(Element& element)
 {
     // Never add elements to the style sharing list if we're not in a recalcStyle,
     // otherwise we could leave stale pointers in there.
-    if (!document().inStyleRecalc())
+    if (!m_document->inStyleRecalc())
         return;
     INCREMENT_STYLE_STATS_COUNTER(*this, sharedStyleCandidates);
     StyleSharingList& list = styleSharingList();
@@ -407,8 +407,8 @@ void StyleResolver::matchAuthorRules(Element* element, ElementRuleCollector& col
     collector.matchedResult().ranges.lastAuthorRule = collector.matchedResult().matchedProperties.size() - 1;
 
     bool applyAuthorStyles = applyAuthorStylesOf(element);
-    if (document().styleEngine()->hasOnlyScopedResolverForDocument()) {
-        document().scopedStyleResolver()->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, ignoreCascadeScope);
+    if (m_document->styleEngine()->hasOnlyScopedResolverForDocument()) {
+        m_document->scopedStyleResolver()->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, ignoreCascadeScope);
         m_treeBoundaryCrossingRules.collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules);
         collector.sortAndTransferMatchedRules();
         return;
@@ -448,14 +448,14 @@ void StyleResolver::matchUARules(ElementRuleCollector& collector)
     matchUARules(collector, userAgentStyleSheet);
 
     // In quirks mode, we match rules from the quirks user agent sheet.
-    if (document().inQuirksMode())
+    if (m_document->inQuirksMode())
         matchUARules(collector, defaultStyleSheets.defaultQuirksStyle());
 
     // If document uses view source styles (in view source mode or in xml viewer mode), then we match rules from the view source style sheet.
-    if (document().isViewSource())
+    if (m_document->isViewSource())
         matchUARules(collector, defaultStyleSheets.defaultViewSourceStyle());
 
-    if (document().isTransitionDocument())
+    if (m_document->isTransitionDocument())
         matchUARules(collector, defaultStyleSheets.defaultTransitionStyle());
 
     collector.setMatchingUARules(false);
@@ -539,7 +539,7 @@ static void addContentAttrValuesToFeatures(const Vector<AtomicString>& contentAt
 
 void StyleResolver::adjustRenderStyle(StyleResolverState& state, Element* element)
 {
-    StyleAdjuster adjuster(document().inQuirksMode());
+    StyleAdjuster adjuster(m_document->inQuirksMode());
     adjuster.adjustRenderStyle(state.style(), state.parentStyle(), element, state.cachedUAStyle());
 }
 
@@ -547,27 +547,27 @@ void StyleResolver::adjustRenderStyle(StyleResolverState& state, Element* elemen
 void StyleResolver::loadPendingResources(StyleResolverState& state)
 {
     m_styleResourceLoader.loadPendingResources(state.style(), state.elementStyleResources());
-    document().styleEngine()->fontSelector()->fontLoader()->loadPendingFonts();
+    m_document->styleEngine()->fontSelector()->fontLoader()->loadPendingFonts();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderStyle* defaultParent, StyleSharingBehavior sharingBehavior,
     RuleMatchingBehavior matchingBehavior)
 {
-    ASSERT(document().frame());
-    ASSERT(document().settings());
+    ASSERT(m_document->frame());
+    ASSERT(m_document->settings());
     ASSERT(!hasPendingAuthorStyleSheets());
     ASSERT(!m_needCollectFeatures);
 
     // Once an element has a renderer, we don't try to destroy it, since otherwise the renderer
     // will vanish if a style recalc happens during loading.
-    if (sharingBehavior == AllowStyleSharing && !document().isRenderingReady() && !element->renderer()) {
+    if (sharingBehavior == AllowStyleSharing && !m_document->isRenderingReady() && !element->renderer()) {
         if (!s_styleNotYetAvailable) {
             s_styleNotYetAvailable = RenderStyle::create().leakRef();
             s_styleNotYetAvailable->setDisplay(NONE);
-            s_styleNotYetAvailable->font().update(document().styleEngine()->fontSelector());
+            s_styleNotYetAvailable->font().update(m_document->styleEngine()->fontSelector());
         }
 
-        document().setHasNodesWithPlaceholderStyle();
+        m_document->setHasNodesWithPlaceholderStyle();
         return s_styleNotYetAvailable;
     }
 
@@ -575,9 +575,9 @@ PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderS
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
-    if (element == document().documentElement())
-        resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), element, defaultParent);
+    if (element == m_document->documentElement())
+        resetDirectionAndWritingModeOnDocument(*m_document);
+    StyleResolverState state(*m_document, element, defaultParent);
 
     if (sharingBehavior == AllowStyleSharing && state.parentStyle()) {
         SharedStyleFinder styleFinder(state.elementContext(), m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
@@ -642,12 +642,12 @@ PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderS
         adjustRenderStyle(state, element);
 
     if (isHTMLBodyElement(*element))
-        document().textLinkColors().setTextColor(state.style()->color());
+        m_document->textLinkColors().setTextColor(state.style()->color());
 
     setAnimationUpdateIfNeeded(state, *element);
 
     if (state.style()->hasViewportUnits())
-        document().setHasViewportUnits();
+        m_document->setHasViewportUnits();
 
     // Now return the style.
     return state.takeStyle();
@@ -655,13 +655,13 @@ PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderS
 
 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(Element& element, const RenderStyle& elementStyle, RenderStyle* parentStyle, const StyleKeyframe* keyframe, const AtomicString& animationName)
 {
-    ASSERT(document().frame());
-    ASSERT(document().settings());
+    ASSERT(m_document->frame());
+    ASSERT(m_document->settings());
     ASSERT(!hasPendingAuthorStyleSheets());
 
-    if (&element == document().documentElement())
-        resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), &element, parentStyle);
+    if (&element == m_document->documentElement())
+        resetDirectionAndWritingModeOnDocument(*m_document);
+    StyleResolverState state(*m_document, &element, parentStyle);
 
     MatchResult result;
     result.addMatchedProperties(&keyframe->properties());
@@ -742,7 +742,7 @@ PassRefPtrWillBeRawPtr<PseudoElement> StyleResolver::createPseudoElementIfNeeded
         return PseudoElement::create(&parent, pseudoId);
     }
 
-    StyleResolverState state(document(), &parent, parentStyle);
+    StyleResolverState state(*m_document, &parent, parentStyle);
     if (!pseudoStyleForElementInternal(parent, pseudoId, parentStyle, state))
         return nullptr;
     RefPtr<RenderStyle> style = state.takeStyle();
@@ -762,8 +762,8 @@ PassRefPtrWillBeRawPtr<PseudoElement> StyleResolver::createPseudoElementIfNeeded
 
 bool StyleResolver::pseudoStyleForElementInternal(Element& element, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle, StyleResolverState& state)
 {
-    ASSERT(document().frame());
-    ASSERT(document().settings());
+    ASSERT(m_document->frame());
+    ASSERT(m_document->settings());
     ASSERT(pseudoStyleRequest.pseudoId != FIRST_LINE_INHERITED);
 
     StyleResolverParentScope::ensureParentStackIsPushed();
@@ -815,7 +815,7 @@ bool StyleResolver::pseudoStyleForElementInternal(Element& element, const Pseudo
     didAccess();
 
     if (state.style()->hasViewportUnits())
-        document().setHasViewportUnits();
+        m_document->setHasViewportUnits();
 
     return true;
 }
@@ -826,7 +826,7 @@ PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(Element* element, c
     if (!element)
         return nullptr;
 
-    StyleResolverState state(document(), element, parentStyle);
+    StyleResolverState state(*m_document, element, parentStyle);
     if (!pseudoStyleForElementInternal(*element, pseudoStyleRequest, parentStyle, state)) {
         if (pseudoStyleRequest.type == PseudoStyleRequest::ForRenderer)
             return nullptr;
@@ -843,11 +843,11 @@ PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(Element* element, c
 PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
 {
     ASSERT(!hasPendingAuthorStyleSheets());
-    resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), document().documentElement()); // m_rootElementStyle will be set to the document style.
+    resetDirectionAndWritingModeOnDocument(*m_document);
+    StyleResolverState state(*m_document, m_document->documentElement()); // m_rootElementStyle will be set to the document style.
 
     state.setStyle(RenderStyle::create());
-    const RenderStyle* rootElementStyle = state.rootElementStyle() ? state.rootElementStyle() : document().renderStyle();
+    const RenderStyle* rootElementStyle = state.rootElementStyle() ? state.rootElementStyle() : m_document->renderStyle();
     ASSERT(rootElementStyle);
     state.style()->inheritFrom(rootElementStyle);
 
@@ -857,7 +857,7 @@ PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
 
     collector.matchPageRules(CSSDefaultStyleSheets::instance().defaultPrintStyle());
 
-    if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
+    if (ScopedStyleResolver* scopedResolver = m_document->scopedStyleResolver())
         scopedResolver->matchPageRules(collector);
 
     state.setLineHeightValue(0);
@@ -890,13 +890,13 @@ void StyleResolver::collectViewportRules()
     CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
     viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultStyle(), ViewportStyleResolver::UserAgentOrigin);
 
-    if (!InspectorInstrumentation::applyViewportStyleOverride(&document(), this))
+    if (!InspectorInstrumentation::applyViewportStyleOverride(m_document, this))
         viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultViewportStyle(), ViewportStyleResolver::UserAgentOrigin);
 
-    if (document().isMobileDocument())
+    if (m_document->isMobileDocument())
         viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultXHTMLMobileProfileStyle(), ViewportStyleResolver::UserAgentOrigin);
 
-    if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
+    if (ScopedStyleResolver* scopedResolver = m_document->scopedStyleResolver())
         scopedResolver->collectViewportRulesTo(this);
 
     viewportStyleResolver()->resolve();
@@ -904,13 +904,13 @@ void StyleResolver::collectViewportRules()
 
 PassRefPtr<RenderStyle> StyleResolver::defaultStyleForElement()
 {
-    StyleResolverState state(document(), 0);
+    StyleResolverState state(*m_document, 0);
     state.setStyle(RenderStyle::create());
-    state.fontBuilder().initForStyleResolve(document(), state.style());
+    state.fontBuilder().initForStyleResolve(*m_document, state.style());
     state.style()->setLineHeight(RenderStyle::initialLineHeight());
     state.setLineHeightValue(0);
     state.fontBuilder().setInitial(state.style()->effectiveZoom());
-    state.style()->font().update(document().styleEngine()->fontSelector());
+    state.style()->font().update(m_document->styleEngine()->fontSelector());
     return state.takeStyle();
 }
 
@@ -926,13 +926,13 @@ PassRefPtr<RenderStyle> StyleResolver::styleForText(Text* textNode)
 
 void StyleResolver::updateFont(StyleResolverState& state)
 {
-    state.fontBuilder().createFont(document().styleEngine()->fontSelector(), state.parentStyle(), state.style());
+    state.fontBuilder().createFont(m_document->styleEngine()->fontSelector(), state.parentStyle(), state.style());
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleList> StyleResolver::styleRulesForElement(Element* element, unsigned rulesToInclude)
 {
     ASSERT(element);
-    StyleResolverState state(document(), element);
+    StyleResolverState state(*m_document, element);
     ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
     collector.setMode(SelectorChecker::CollectingStyleRules);
     collectPseudoRulesForElement(element, collector, NOPSEUDO, rulesToInclude);
@@ -942,7 +942,7 @@ PassRefPtrWillBeRawPtr<StyleRuleList> StyleResolver::styleRulesForElement(Elemen
 PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::pseudoCSSRulesForElement(Element* element, PseudoId pseudoId, unsigned rulesToInclude)
 {
     ASSERT(element);
-    StyleResolverState state(document(), element);
+    StyleResolverState state(*m_document, element);
     ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
     collector.setMode(SelectorChecker::CollectingCSSRules);
     collectPseudoRulesForElement(element, collector, pseudoId, rulesToInclude);
@@ -1533,7 +1533,7 @@ void StyleResolver::printStats()
 {
     if (!m_styleResolverStats)
         return;
-    fprintf(stderr, "=== Style Resolver Stats (resolve #%u) (%s) ===\n", ++m_styleResolverStatsSequence, document().url().string().utf8().data());
+    fprintf(stderr, "=== Style Resolver Stats (resolve #%u) (%s) ===\n", ++m_styleResolverStatsSequence, m_document->url().string().utf8().data());
     fprintf(stderr, "%s\n", m_styleResolverStats->report().utf8().data());
     fprintf(stderr, "== Totals ==\n");
     fprintf(stderr, "%s\n", m_styleResolverStatsTotals->report().utf8().data());
@@ -1541,10 +1541,10 @@ void StyleResolver::printStats()
 
 void StyleResolver::applyPropertiesToStyle(const CSSPropertyValue* properties, size_t count, RenderStyle* style)
 {
-    StyleResolverState state(document(), document().documentElement(), style);
+    StyleResolverState state(*m_document, m_document->documentElement(), style);
     state.setStyle(style);
 
-    state.fontBuilder().initForStyleResolve(document(), style);
+    state.fontBuilder().initForStyleResolve(*m_document, style);
 
     for (size_t i = 0; i < count; ++i) {
         if (properties[i].value) {