Moved element style recalc count and stats to StyleEngine.

third_party/WebKit/Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 128 matching lines @@
         }
     }
 }
 
 StyleResolver::StyleResolver(Document& document)
     : m_document(document)
     , m_viewportStyleResolver(ViewportStyleResolver::create(&document))
     , m_needCollectFeatures(false)
     , m_printMediaType(false)
     , m_styleSharingDepth(0)
-    , m_accessCount(0)
 {
     FrameView* view = document.view();
     if (view) {
         m_medium = adoptPtrWillBeNoop(new MediaQueryEvaluator(&view->frame()));
         m_printMediaType = equalIgnoringCase(view->mediaType(), MediaTypeNames::print);
     } else {
         m_medium = adoptPtrWillBeNoop(new MediaQueryEvaluator("all"));
     }
 
     initWatchedSelectorRules();
@@ skipping 162 matching lines @@
     return m_features.hasSelectorForId(id);
 }
 
 void StyleResolver::addToStyleSharingList(Element& element)
 {
     ASSERT(RuntimeEnabledFeatures::styleSharingEnabled());
     // 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())
         return;
-    INCREMENT_STYLE_STATS_COUNTER(*this, sharedStyleCandidates, 1);
+    INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), sharedStyleCandidates, 1);
     StyleSharingList& list = styleSharingList();
     if (list.size() >= styleSharingListSize)
         list.removeLast();
     list.prepend(&element);
 }
 
 StyleSharingList& StyleResolver::styleSharingList()
 {
     m_styleSharingLists.resize(styleSharingMaxDepth);
 
@@ skipping 226 matching lines @@
         if (!s_styleNotYetAvailable) {
             s_styleNotYetAvailable = ComputedStyle::create().leakRef();
             s_styleNotYetAvailable->setDisplay(NONE);
             s_styleNotYetAvailable->font().update(document().styleEngine().fontSelector());
         }
 
         document().setHasNodesWithPlaceholderStyle();
         return s_styleNotYetAvailable;
     }
 
-    didAccess();
-    INCREMENT_STYLE_STATS_COUNTER(*this, elementsStyled, 1);
+    document().styleEngine().incStyleForElementCount();
+    INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), elementsStyled, 1);
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
     ElementResolveContext elementContext(*element);
 
     if (RuntimeEnabledFeatures::styleSharingEnabled() && sharingBehavior == AllowStyleSharing && (defaultParent || elementContext.parentStyle())) {
         SharedStyleFinder styleFinder(elementContext, m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
         if (RefPtr<ComputedStyle> sharedStyle = styleFinder.findSharedStyle())
             return sharedStyle.release();
     }
@@ skipping 63 matching lines @@
         applyCallbackSelectors(state);
 
         // Cache our original display.
         state.style()->setOriginalDisplay(state.style()->display());
 
         adjustComputedStyle(state, element);
 
         if (elementAnimations)
             elementAnimations->updateBaseComputedStyle(state.style());
     } else {
-        INCREMENT_STYLE_STATS_COUNTER(*this, baseStylesUsed, 1);
+        INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), baseStylesUsed, 1);
     }
 
     // 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)) {
-        INCREMENT_STYLE_STATS_COUNTER(*this, stylesAnimated, 1);
+        INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesAnimated, 1);
         adjustComputedStyle(state, element);
     }
 
     if (isHTMLBodyElement(*element))
         document().textLinkColors().setTextColor(state.style()->color());
 
     setAnimationUpdateIfNeeded(state, *element);
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
@@ skipping 130 matching lines @@
         if (elementAnimations)
             elementAnimations->updateBaseComputedStyle(state.style());
     }
 
     // FIXME: The CSSWG wants to specify that the effects of animations are applied before
     // important rules, but this currently happens here as we require adjustment to have happened
     // before deciding which properties to transition.
     if (applyAnimatedProperties(state, pseudoElement))
         adjustComputedStyle(state, 0);
 
-    didAccess();
-    INCREMENT_STYLE_STATS_COUNTER(*this, pseudoElementsStyled, 1);
+    document().styleEngine().incStyleForElementCount();
+    INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), pseudoElementsStyled, 1);
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
 
     return true;
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::pseudoStyleForElement(Element* element, const PseudoStyleRequest& pseudoStyleRequest, const ComputedStyle* parentStyle)
 {
     ASSERT(parentStyle);
@@ skipping 37 matching lines @@
     const MatchResult& result = collector.matchedResult();
     applyMatchedProperties<HighPropertyPriority>(state, result.allRules(), false, inheritedOnly);
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
     applyMatchedProperties<LowPropertyPriority>(state, result.allRules(), false, inheritedOnly);
 
     loadPendingResources(state);
 
-    didAccess();
-
     // Now return the style.
     return state.takeStyle();
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::initialStyleForElement()
 {
     RefPtr<ComputedStyle> style = ComputedStyle::create();
     FontBuilder fontBuilder(document());
     fontBuilder.setInitial(style->effectiveZoom());
     fontBuilder.createFont(document().styleEngine().fontSelector(), *style);
@@ skipping 448 matching lines @@
 {
     m_viewportStyleResolver->collectViewportRules();
     m_matchedPropertiesCache.clearViewportDependent();
 }
 
 void StyleResolver::applyMatchedProperties(StyleResolverState& state, const MatchResult& matchResult)
 {
     const Element* element = state.element();
     ASSERT(element);
 
-    INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyApply, 1);
+    INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), matchedPropertyApply, 1);
 
     unsigned cacheHash = RuntimeEnabledFeatures::styleMatchedPropertiesCacheEnabled() && matchResult.isCacheable() ? computeMatchedPropertiesHash(matchResult.matchedProperties().data(), matchResult.matchedProperties().size()) : 0;
     bool applyInheritedOnly = false;
     const CachedMatchedProperties* cachedMatchedProperties = cacheHash ? m_matchedPropertiesCache.find(cacheHash, state, matchResult.matchedProperties()) : nullptr;
 
     if (cachedMatchedProperties && MatchedPropertiesCache::isCacheable(*state.style(), *state.parentStyle())) {
-        INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheHit, 1);
+        INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), matchedPropertyCacheHit, 1);
         // We can build up the style by copying non-inherited properties from an earlier style object built using the same exact
         // 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()->copyNonInheritedFromCached(*cachedMatchedProperties->computedStyle);
         if (state.parentStyle()->inheritedDataShared(*cachedMatchedProperties->parentComputedStyle) && !isAtShadowBoundary(element)
             && (!state.distributedToInsertionPoint() || state.style()->userModify() == READ_ONLY)) {
-            INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheInheritedHit, 1);
+            INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), matchedPropertyCacheInheritedHit, 1);
 
             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(*cachedMatchedProperties->computedStyle);
 
             // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
             state.style()->setInsideLink(linkStatus);
 
             updateFont(state);
@@ skipping 61 matching lines @@
         // and the value stored in cacheUserAgentBorderAndBackground is incorrect, so doing this check again
         // would give the wrong answer.
         state.style()->setHasAuthorBackground(hasAuthorBackground(state));
         state.style()->setHasAuthorBorder(hasAuthorBorder(state));
     }
 
     loadPendingResources(state);
 
     if (!cachedMatchedProperties && cacheHash && MatchedPropertiesCache::isCacheable(*state.style(), *state.parentStyle())) {
         ASSERT(RuntimeEnabledFeatures::styleMatchedPropertiesCacheEnabled());
-        INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheAdded, 1);
+        INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), matchedPropertyCacheAdded, 1);
         m_matchedPropertiesCache.add(*state.style(), *state.parentStyle(), cacheHash, matchResult.matchedProperties());
     }
 
     ASSERT(!state.fontBuilder().fontDirty());
 }
 
 bool StyleResolver::hasAuthorBackground(const StyleResolverState& state)
 {
     const CachedUAStyle* cachedUAStyle = state.cachedUAStyle();
     if (!cachedUAStyle)
@@ skipping 29 matching lines @@
     collector.collectMatchingRules(matchRequest);
     collector.sortAndTransferMatchedRules();
 
     RefPtrWillBeRawPtr<StyleRuleList> rules = collector.matchedStyleRuleList();
     if (!rules)
         return;
     for (size_t i = 0; i < rules->size(); i++)
         state.style()->addCallbackSelector(rules->at(i)->selectorList().selectorsText());
 }
 
-void StyleResolver::setStatsEnabled(bool enabled)
-{
-    if (enabled) {
-        if (!m_styleResolverStats) {
-            m_styleResolverStats = StyleResolverStats::create();
-        } else {
-            m_styleResolverStats->reset();
-        }
-    } else {
-        m_styleResolverStats = nullptr;
-    }
-}
-
 void StyleResolver::computeFont(ComputedStyle* style, const StylePropertySet& propertySet)
 {
     CSSPropertyID properties[] = {
         CSSPropertyFontSize,
         CSSPropertyFontFamily,
         CSSPropertyFontStretch,
         CSSPropertyFontStyle,
         CSSPropertyFontVariant,
         CSSPropertyFontWeight,
         CSSPropertyLineHeight,
@@ skipping 54 matching lines @@
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingScopes);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink