Prune the API of StyleResolver.

sky/engine/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 101 matching lines @@
 
     ruleSet = RuleSet::create();
     ruleSet->addRulesFromSheet(styleSheet.get());
 
     return *ruleSet;
 }
 
 StyleResolver::StyleResolver(Document& document)
     : m_document(document)
     , m_styleResolverStatsSequence(0)
-    , m_accessCount(0)
 {
 }
 
 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;
     ASSERT(element.supportsStyleSharing());
     INCREMENT_STYLE_STATS_COUNTER(*this, sharedStyleCandidates);
     StyleSharingList& list = styleSharingList();
     if (list.size() >= styleSharingListSize)
         list.removeLast();
     list.prepend(&element);
 }
 
 void StyleResolver::clearStyleSharingList()
@@ skipping 56 matching lines @@
     documentStyle->setZIndex(0);
     documentStyle->setUserModify(READ_ONLY);
 
     document.setupFontBuilder(documentStyle.get());
 
     return documentStyle.release();
 }
 
 void StyleResolver::loadPendingResources(StyleResolverState& state)
 {
-    StyleResourceLoader loader(document().fetcher());
+    StyleResourceLoader loader(m_document.fetcher());
     loader.loadPendingResources(state.style(), state.elementStyleResources());
-    document().styleEngine()->fontSelector()->fontLoader()->loadPendingFonts();
+    m_document.styleEngine()->fontSelector()->fontLoader()->loadPendingFonts();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderStyle* defaultParent)
 {
-    ASSERT(document().frame());
-    ASSERT(document().settings());
+    ASSERT(m_document.frame());
+    ASSERT(m_document.settings());
 
-    didAccess();
-
-    if (element == document().documentElement())
-        document().setDirectionSetOnDocumentElement(false);
-    StyleResolverState state(document(), element, defaultParent);
+    if (element == m_document.documentElement())
+        m_document.setDirectionSetOnDocumentElement(false);
+    StyleResolverState state(m_document, element, defaultParent);
 
     if (state.parentStyle()) {
         SharedStyleFinder styleFinder(state.elementContext(), *this);
         if (RefPtr<RenderStyle> sharedStyle = styleFinder.findSharedStyle())
             return sharedStyle.release();
     }
 
     if (state.parentStyle()) {
         state.setStyle(RenderStyle::create());
         state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
@@ skipping 28 matching lines @@
 
     // FIXME: The CSSWG wants to specify that the effects of animations are applied before
     // important rules, but this currently happens here as we require adjustment to have happened
     // before deciding which properties to transition.
     if (applyAnimatedProperties(state, element))
         adjuster.adjustRenderStyle(state.style(), state.parentStyle(), *element);
 
     setAnimationUpdateIfNeeded(state, *element);
 
     if (state.style()->hasViewportUnits())
-        document().setHasViewportUnits();
+        m_document.setHasViewportUnits();
 
     // Now return the style.
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(Element* element, const RenderStyle& elementStyle, RenderStyle* parentStyle, const StyleKeyframe* keyframe, const AtomicString& animationName)
 {
-    ASSERT(document().frame());
-    ASSERT(document().settings());
+    ASSERT(m_document.frame());
+    ASSERT(m_document.settings());
 
-    if (element == document().documentElement())
-        document().setDirectionSetOnDocumentElement(false);
-    StyleResolverState state(document(), element, parentStyle);
+    if (element == m_document.documentElement())
+        m_document.setDirectionSetOnDocumentElement(false);
+    StyleResolverState state(m_document, element, parentStyle);
 
     MatchResult result;
     result.addMatchedProperties(&keyframe->properties());
 
     ASSERT(!state.style());
 
     // Create the style
     state.setStyle(RenderStyle::clone(&elementStyle));
     state.setLineHeightValue(0);
 
@@ skipping 12 matching lines @@
 
     // Line-height is set when we are sure we decided on the font-size
     if (state.lineHeightValue())
         StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
 
     // Now do rest of the properties.
     applyMatchedProperties<LowPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     loadPendingResources(state);
 
-    didAccess();
-
     return state.takeStyle();
 }
 
 // This function is used by the WebAnimations JavaScript API method animate().
 // FIXME: Remove this when animate() switches away from resolution-dependent parsing.
 PassRefPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(Element& element, CSSPropertyID property, CSSValue& value)
 {
     RefPtr<RenderStyle> style;
     if (element.renderStyle())
         style = RenderStyle::clone(element.renderStyle());
     else
         style = RenderStyle::create();
     StyleResolverState state(element.document(), &element);
     state.setStyle(style);
     state.fontBuilder().initForStyleResolve(state.document(), state.style());
     return createAnimatableValueSnapshot(state, property, value);
 }
 
 PassRefPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(StyleResolverState& state, CSSPropertyID property, CSSValue& value)
 {
     StyleBuilder::applyProperty(property, state, &value);
     return CSSAnimatableValueFactory::create(property, *state.style());
 }
 
 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()->font().update(document().styleEngine()->fontSelector());
+    state.style()->font().update(m_document.styleEngine()->fontSelector());
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForText(Text* textNode)
 {
     ASSERT(textNode);
 
     Node* parentNode = NodeRenderingTraversal::parent(textNode);
     if (!parentNode || !parentNode->renderStyle())
         return defaultStyleForElement();
     return parentNode->renderStyle();
 }
 
 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());
     if (state.fontBuilder().fontSizeHasViewportUnits())
         state.style()->setHasViewportUnits();
 }
 
 // -------------------------------------------------------------------------------------
 // this is mostly boring stuff on how to apply a certain rule to the renderstyle...
 
 bool StyleResolver::applyAnimatedProperties(StyleResolverState& state, Element* animatingElement)
 {
     const Element* element = state.element();
@@ skipping 280 matching lines @@
 {
     m_styleResolverStatsSequence = 0;
     m_styleResolverStats.clear();
     m_styleResolverStatsTotals.clear();
 }
 
 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());
 }
 
 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) {
             // As described in BUG66291, setting font-size and line-height on a font may entail a CSSPrimitiveValue::computeLengthDouble call,
             // which assumes the fontMetrics are available for the affected font, otherwise a crash occurs (see http://trac.webkit.org/changeset/96122).
             // The updateFont() call below updates the fontMetrics and ensure the proper setting of font-size and line-height.
             switch (properties[i].property) {
             case CSSPropertyFontSize:
             case CSSPropertyLineHeight:
                 updateFont(state);
                 break;
             default:
                 break;
             }
             StyleBuilder::applyProperty(properties[i].property, state, properties[i].value);
         }
     }
 }
 
 } // namespace blink