Moving fontSelector from StyleResolver to StyleEngine.

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 113 matching lines @@
 
 static void addFontFaceRule(Document* document, CSSFontSelector* cssFontSelector, const StyleRuleFontFace* fontFaceRule)
 {
     RefPtr<CSSFontFace> cssFontFace = CSSFontFace::createFromStyleRule(document, fontFaceRule);
     if (cssFontFace)
         cssFontSelector->addFontFaceRule(fontFaceRule, cssFontFace);
 }
 
 StyleResolver::StyleResolver(Document& document)
     : m_document(document)
-    , m_fontSelector(CSSFontSelector::create(&document))
     , m_viewportStyleResolver(ViewportStyleResolver::create(&document))
     , m_needCollectFeatures(false)
     , m_styleResourceLoader(document.fetcher())
     , m_styleResolverStatsSequence(0)
     , m_accessCount(0)
 {
-    m_fontSelector->registerForInvalidationCallbacks(this);
-
     // FIXME: Why do this here instead of as part of resolving style on the root?
     CSSDefaultStyleSheets::loadDefaultStylesheetIfNecessary();
 
     // Construct document root element default style. This is needed
     // to evaluate media queries that contain relative constraints, like "screen and (max-width: 10em)"
     // This is here instead of constructor because when constructor is run,
     // Document doesn't have documentElement.
     // NOTE: This assumes that element that gets passed to the styleForElement call
     // is always from the document that owns the StyleResolver.
     FrameView* view = document.view();
@@ skipping 11 matching lines @@
 
     m_styleTree.clear();
 
     initWatchedSelectorRules(CSSSelectorWatch::from(document).watchedCallbackSelectors());
 
 #if ENABLE(SVG_FONTS)
     if (document.svgExtensions()) {
         const HashSet<SVGFontFaceElement*>& svgFontFaceElements = document.svgExtensions()->svgFontFaceElements();
         HashSet<SVGFontFaceElement*>::const_iterator end = svgFontFaceElements.end();
         for (HashSet<SVGFontFaceElement*>::const_iterator it = svgFontFaceElements.begin(); it != end; ++it)
-            addFontFaceRule(&document, fontSelector(), (*it)->fontFaceRule());
+            addFontFaceRule(&document, document.styleEngine()->fontSelector(), (*it)->fontFaceRule());
     }
 #endif
 }
 
 void StyleResolver::initWatchedSelectorRules(const Vector<RefPtr<StyleRule> >& watchedSelectors)
 {
     if (!watchedSelectors.size())
         return;
     m_watchedSelectorsRules = RuleSet::create();
     for (unsigned i = 0; i < watchedSelectors.size(); ++i)
@@ skipping 48 matching lines @@
     unsigned size = styleSheets.size();
     for (unsigned i = firstNew; i < size; ++i)
         appendCSSStyleSheet(styleSheets[i].get());
 }
 
 void StyleResolver::finishAppendAuthorStyleSheets()
 {
     collectFeatures();
 
     if (document().renderer() && document().renderer()->style())
-        document().renderer()->style()->font().update(fontSelector());
+        document().renderer()->style()->font().update(document().styleEngine()->fontSelector());
 
     collectViewportRules();
 
     document().styleEngine()->resetCSSFeatureFlags(m_features);
 }
 
 void StyleResolver::resetRuleFeatures()
 {
     // Need to recreate RuleFeatureSet.
     m_features.clear();
@@ skipping 15 matching lines @@
     const Vector<StyleRuleKeyframes*> keyframesRules = authorRules.keyframesRules();
     for (unsigned i = 0; i < keyframesRules.size(); ++i)
         ensureScopedStyleResolver(scope)->addKeyframeStyle(keyframesRules[i]);
 
     addTreeBoundaryCrossingRules(authorRules.treeBoundaryCrossingRules(), scope);
 
     // FIXME(BUG 72461): We don't add @font-face rules of scoped style sheets for the moment.
     if (!scope || scope->isDocumentNode()) {
         const Vector<StyleRuleFontFace*> fontFaceRules = authorRules.fontFaceRules();
         for (unsigned i = 0; i < fontFaceRules.size(); ++i)
-            addFontFaceRule(&m_document, fontSelector(), fontFaceRules[i]);
+            addFontFaceRule(&m_document, document().styleEngine()->fontSelector(), fontFaceRules[i]);
         if (fontFaceRules.size())
             invalidateMatchedPropertiesCache();
     } else {
         addTreeBoundaryCrossingRules(authorRules.shadowDistributedRules(), scope);
     }
 }
 
-void StyleResolver::resetFontSelector()
-{
-    ASSERT(m_fontSelector);
-    m_fontSelector->unregisterForInvalidationCallbacks(this);
-    m_fontSelector->clearDocument();
-    invalidateMatchedPropertiesCache();
-
-    m_fontSelector = CSSFontSelector::create(&m_document);
-    m_fontSelector->registerForInvalidationCallbacks(this);
-}
-
 void StyleResolver::resetAuthorStyle(const ContainerNode* scopingNode)
 {
     // FIXME: When chanking scoped attribute, scopingNode's hasScopedHTMLStyleChild has been already modified.
     // So we cannot use hasScopedHTMLStyleChild flag here.
     ScopedStyleResolver* resolver = scopingNode ? m_styleTree.lookupScopedStyleResolverFor(scopingNode) : m_styleTree.scopedStyleResolverForDocument();
     if (!resolver)
         return;
 
     treeBoundaryCrossingRules().reset(scopingNode);
 
@@ skipping 102 matching lines @@
 }
 
 void StyleResolver::popParentShadowRoot(const ShadowRoot& shadowRoot)
 {
     ASSERT(shadowRoot.host());
     m_styleTree.popStyleCache(shadowRoot);
 }
 
 StyleResolver::~StyleResolver()
 {
-    m_fontSelector->unregisterForInvalidationCallbacks(this);
-    m_fontSelector->clearDocument();
     m_viewportStyleResolver->clearDocument();
 }
 
 inline void StyleResolver::collectTreeBoundaryCrossingRules(Element* element, ElementRuleCollector& collector, bool includeEmptyRules)
 {
     if (m_treeBoundaryCrossingRules.isEmpty())
         return;
 
     RuleRange ruleRange = collector.matchedResult().ranges.authorRuleRange();
 
@@ skipping 225 matching lines @@
     ASSERT(documentSettings());
     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 && !element->document().haveStylesheetsLoaded() && !element->renderer()) {
         if (!s_styleNotYetAvailable) {
             s_styleNotYetAvailable = RenderStyle::create().leakRef();
             s_styleNotYetAvailable->setDisplay(NONE);
-            s_styleNotYetAvailable->font().update(m_fontSelector);
+            s_styleNotYetAvailable->font().update(document().styleEngine()->fontSelector());
         }
         element->document().setHasNodesWithPlaceholderStyle();
         return s_styleNotYetAvailable;
     }
 
     didAccess();
 
     if (element == document().documentElement())
         resetDirectionAndWritingModeOnDocument(document());
     StyleResolverState state(document(), element, defaultParent, regionForStyling);
@@ skipping 121 matching lines @@
     // Now do rest of the properties.
     if (keyframe->properties())
         applyMatchedProperties<LowPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     // If our font got dirtied by one of the non-essential font props,
     // go ahead and update it a second time.
     updateFont(state);
 
     // Start loading resources referenced by this style.
     m_styleResourceLoader.loadPendingResources(state.style(), state.elementStyleResources());
-    m_fontSelector->loadPendingFonts();
+    document().styleEngine()->fontSelector()->loadPendingFonts();
 
     didAccess();
 
     return state.takeStyle();
 }
 
 void StyleResolver::keyframeStylesForAnimation(Element* e, const RenderStyle& elementStyle, KeyframeList& list)
 {
     ASSERT(!RuntimeEnabledFeatures::webAnimationsCSSEnabled());
     list.clear();
@@ skipping 143 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());
 
     applyMatchedProperties<LowPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 
     // Start loading resources referenced by this style.
     m_styleResourceLoader.loadPendingResources(state.style(), state.elementStyleResources());
-    m_fontSelector->loadPendingFonts();
+    document().styleEngine()->fontSelector()->loadPendingFonts();
 
     didAccess();
 
     // Now return the style.
     return state.takeStyle();
 }
 
 void StyleResolver::collectViewportRules()
 {
     viewportStyleResolver()->collectViewportRules(CSSDefaultStyleSheets::defaultStyle, ViewportStyleResolver::UserAgentOrigin);
@@ skipping 11 matching lines @@
 }
 
 PassRefPtr<RenderStyle> StyleResolver::defaultStyleForElement()
 {
     StyleResolverState state(document(), 0);
     state.setStyle(RenderStyle::create());
     state.fontBuilder().initForStyleResolve(document(), state.style(), state.useSVGZoomRules());
     state.style()->setLineHeight(RenderStyle::initialLineHeight());
     state.setLineHeightValue(0);
     state.fontBuilder().setInitial(state.style()->effectiveZoom());
-    state.style()->font().update(fontSelector());
+    state.style()->font().update(document().styleEngine()->fontSelector());
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForText(Text* textNode)
 {
     ASSERT(textNode);
 
     NodeRenderingTraversal::ParentDetails parentDetails;
     Node* parentNode = NodeRenderingTraversal::parent(textNode, &parentDetails);
     if (!parentNode || !parentNode->renderStyle() || parentDetails.resetStyleInheritance())
         return defaultStyleForElement();
     return parentNode->renderStyle();
 }
 
 bool StyleResolver::checkRegionStyle(Element* regionElement)
 {
     // FIXME (BUG 72472): We don't add @-webkit-region rules of scoped style sheets for the moment,
     // so all region rules are global by default. Verify whether that can stand or needs changing.
     if (ScopedStyleResolver* scopedResolver = m_styleTree.scopedStyleResolverForDocument()) {
         if (scopedResolver->checkRegionStyle(regionElement))
             return true;
     }
     return false;
 }
 
 void StyleResolver::updateFont(StyleResolverState& state)
 {
-    state.fontBuilder().createFont(m_fontSelector, state.parentStyle(), state.style());
+    state.fontBuilder().createFont(document().styleEngine()->fontSelector(), state.parentStyle(), state.style());
 }
 
 PassRefPtr<StyleRuleList> StyleResolver::styleRulesForElement(Element* element, unsigned rulesToInclude)
 {
     ASSERT(element);
     StyleResolverState state(document(), element);
     ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
     collector.setMode(SelectorChecker::CollectingStyleRules);
     collectPseudoRulesForElement(element, collector, NOPSEUDO, rulesToInclude);
     return collector.matchedStyleRuleList();
@@ skipping 312 matching lines @@
     state.cacheUserAgentBorderAndBackground();
 
     // Now do the author and user normal priority properties and all the !important properties.
     applyMatchedProperties<LowPriorityProperties>(state, matchResult, false, matchResult.ranges.lastUARule + 1, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
     applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
     applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
     // Start loading resources referenced by this style.
     m_styleResourceLoader.loadPendingResources(state.style(), state.elementStyleResources());
-    m_fontSelector->loadPendingFonts();
+    document().styleEngine()->fontSelector()->loadPendingFonts();
 
     if (!cachedMatchedProperties && cacheHash && MatchedPropertiesCache::isCacheable(element, state.style(), state.parentStyle())) {
         INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheAdded);
         m_matchedPropertiesCache.add(state.style(), state.parentStyle(), cacheHash, matchResult);
     }
 
     applyAnimatedProperties(state, animatingElement);
 
     ASSERT(!state.fontBuilder().fontDirty());
 }
@@ skipping 65 matching lines @@
 bool StyleResolver::affectedByViewportChange() const
 {
     for (unsigned i = 0; i < m_viewportDependentMediaQueryResults.size(); ++i) {
         if (m_medium->eval(&m_viewportDependentMediaQueryResults[i]->m_expression) != m_viewportDependentMediaQueryResults[i]->m_result)
             return true;
     }
     return false;
 }
 
 } // namespace WebCore