StyleResolver should update RuleSets lazily.

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 39 matching lines @@
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSVariableValue.h"
 #include "core/css/ElementRuleCollector.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/css/PageRuleCollector.h"
 #include "core/css/RuleSet.h"
 #include "core/css/StylePropertySet.h"
+#include "core/css/StyleRuleImport.h"
+#include "core/css/StyleSheetContents.h"
 #include "core/css/resolver/AnimatedStyleBuilder.h"
 #include "core/css/resolver/MatchResult.h"
 #include "core/css/resolver/MediaQueryResult.h"
 #include "core/css/resolver/SharedStyleFinder.h"
 #include "core/css/resolver/StyleAdjuster.h"
 #include "core/css/resolver/StyleBuilder.h"
 #include "core/css/resolver/ViewportStyleResolver.h"
 #include "core/dom/CSSSelectorWatch.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/dom/StyleEngine.h"
@@ skipping 61 matching lines @@
     if (rightToLeftDecl->isEmpty())
         rightToLeftDecl->setProperty(CSSPropertyDirection, CSSValueRtl);
     return rightToLeftDecl.get();
 }
 
 StyleResolver::StyleResolver(Document& document, bool matchAuthorAndUserStyles)
     : m_document(document)
     , m_matchAuthorAndUserStyles(matchAuthorAndUserStyles)
     , m_fontSelector(CSSFontSelector::create(&document))
     , m_viewportStyleResolver(ViewportStyleResolver::create(&document))
+    , m_needCollectFeatures(false)
     , m_styleResourceLoader(document.fetcher())
 {
     Element* root = document.documentElement();
 
     m_fontSelector->registerForInvalidationCallbacks(this);
 
     CSSDefaultStyleSheets::initDefaultStyle(root);
 
     // construct document root element default style. this is needed
     // to evaluate media queries that contain relative constraints, like "screen and (max-width: 10em)"
@@ skipping 23 matching lines @@
         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)
             fontSelector()->addFontFaceRule((*it)->fontFaceRule());
     }
 #endif
 
     styleSheetCollection->appendActiveAuthorStyleSheets(this);
 }
 
+void StyleResolver::filterFontFaceAndViewportRules(const Vector<RefPtr<StyleRuleBase> >& rules, bool& needsResolveViewport)
+{
+    for (unsigned i = 0; i < rules.size(); ++i) {
+        StyleRuleBase* rule = rules[i].get();
+
+        if (rule->isFontFaceRule()) {
+            const StyleRuleFontFace* fontFaceRule = static_cast<StyleRuleFontFace*>(rule);

[eseidel, 2013/11/06 01:39:10]

Do we have a toStyleRuleFontFace() method instead (which does necessarily
RELEASE_ASSERTs, etc.?)

[tasak, 2013/11/06 05:42:26]

Done.

+            fontSelector()->addFontFaceRule(fontFaceRule);
+            invalidateMatchedPropertiesCache();
+        } else if (rule->isViewportRule()) {
+            m_styleTree.ensureScopedStyleResolver(m_document)->addViewportRule(static_cast<StyleRuleViewport*>(rule));
+            needsResolveViewport = true;
+        } else if (rule->isMediaRule()) {
+            StyleRuleMedia* mediaRule = static_cast<StyleRuleMedia*>(rule);

[eseidel, 2013/11/06 01:39:10]

We've slowly been moving away from using static_cast directly in Blink when
possible and always using toFoo() functions instead since those include ASSERTS
to catch bad casts (before security vulnerabilities happen).

[tasak, 2013/11/06 05:42:26]

Done.

+            if ((!mediaRule->mediaQueries() || m_medium->eval(mediaRule->mediaQueries(), viewportDependentMediaQueryResults())))
+                filterFontFaceAndViewportRules(mediaRule->childRules(), needsResolveViewport);
+        }
+    }
+}
+
+void StyleResolver::filterFontFaceAndViewportRulesFromSheet(StyleSheetContents* sheet, bool& needsResolveViewport)
+{
+    if (!sheet)
+        return;
+
+    if (sheet->importRules().size() > 0) {
+        const Vector<RefPtr<StyleRuleImport> >& importRules = sheet->importRules();
+        for (unsigned i = 0; i < importRules.size(); ++i) {
+            StyleRuleImport* importRule = importRules[i].get();
+            filterFontFaceAndViewportRulesFromSheet(importRule->styleSheet(), needsResolveViewport);
+        }
+    }
+    filterFontFaceAndViewportRules(sheet->childRules(), needsResolveViewport);
+}
+
+bool StyleResolver::filterFontFaceAndViewportRulesFromAuthorStyleSheets(unsigned firstNew, const Vector<RefPtr<CSSStyleSheet> >& styleSheets)
+{
+    bool needsResolveViewport = false;
+
+    unsigned size = styleSheets.size();
+    for (unsigned i = firstNew; i < size; ++i) {
+        CSSStyleSheet* cssSheet = styleSheets[i].get();
+        ASSERT(!cssSheet->disabled());
+        if (cssSheet->mediaQueries() && !m_medium->eval(cssSheet->mediaQueries(), &m_viewportDependentMediaQueryResults))
+            continue;
+        // @viewport and @font-face rules work only in document scope.
+        if (cssSheet->ownerNode()->isInShadowTree() || !isDocumentScope(ScopedStyleResolver::scopingNodeFor(cssSheet)))
+            continue;
+        filterFontFaceAndViewportRulesFromSheet(cssSheet->contents(), needsResolveViewport);
+    }
+    return needsResolveViewport;
+}
+
+void StyleResolver::lazyAppendAuthorStyleSheets(unsigned firstNew, const Vector<RefPtr<CSSStyleSheet> >& styleSheets)
+{
+    // FIXME: Currently We cannot lazy apppend stylesheets if the sheets have @viewport and @font-face rules.
+    // Need to find the best place to update pending stylesheets for "viewport" rules.
+    // Talking about @font-face rules, addFontFaceRule triggers loading font resources.
+    // If we delays "addFontFaceRule", we probably wait more time until fonts are loaded.
+    // At least, we should filter @viewport and @font-face here and should lazily add other rules if possible.
+    bool needsResolveViewport = filterFontFaceAndViewportRulesFromAuthorStyleSheets(firstNew, styleSheets);
+
+    unsigned size = styleSheets.size();
+    for (unsigned i = firstNew; i < size; ++i)
+        m_pendingStyleSheets.add(styleSheets[i].get());
+
+    if (needsResolveViewport)
+        collectViewportRules();
+}
+
+void StyleResolver::removePendingAuthorStyleSheets(const Vector<RefPtr<CSSStyleSheet> >& styleSheets)
+{
+    for (unsigned i = 0; i < styleSheets.size(); ++i)
+        m_pendingStyleSheets.remove(styleSheets[i].get());
+}
+
+void StyleResolver::appendPendingAuthorStyleSheets()
+{
+    setBuildScopedStyleTreeInDocumentOrder(false);
+    for (ListHashSet<CSSStyleSheet*, 16>::iterator it = m_pendingStyleSheets.begin(); it != m_pendingStyleSheets.end(); ++it) {
+        CSSStyleSheet* cssSheet = *it;
+        ASSERT(!cssSheet->disabled());
+        if (cssSheet->mediaQueries() && !m_medium->eval(cssSheet->mediaQueries(), &m_viewportDependentMediaQueryResults))
+            continue;
+
+        StyleSheetContents* sheet = cssSheet->contents();
+        const ContainerNode* scopingNode = ScopedStyleResolver::scopingNodeFor(cssSheet);
+        if (!scopingNode && cssSheet->ownerNode() && cssSheet->ownerNode()->isInShadowTree())
+            continue;
+
+        ScopedStyleResolver* resolver = ensureScopedStyleResolver(scopingNode);
+        ASSERT(resolver);
+        resolver->addRulesFromSheet(sheet, *m_medium, this, false);
+        m_inspectorCSSOMWrappers.collectFromStyleSheetIfNeeded(cssSheet);
+    }
+    m_pendingStyleSheets.clear();
+    finishAppendAuthorStyleSheets();
+}
+
 void StyleResolver::appendAuthorStyleSheets(unsigned firstNew, const Vector<RefPtr<CSSStyleSheet> >& styleSheets)
 {
     // This handles sheets added to the end of the stylesheet list only. In other cases the style resolver
     // needs to be reconstructed. To handle insertions too the rule order numbers would need to be updated.
     unsigned size = styleSheets.size();
     for (unsigned i = firstNew; i < size; ++i) {
         CSSStyleSheet* cssSheet = styleSheets[i].get();
         ASSERT(!cssSheet->disabled());
         if (cssSheet->mediaQueries() && !m_medium->eval(cssSheet->mediaQueries(), &m_viewportDependentMediaQueryResults))
             continue;
 
         StyleSheetContents* sheet = cssSheet->contents();
         const ContainerNode* scopingNode = ScopedStyleResolver::scopingNodeFor(cssSheet);
         if (!scopingNode && cssSheet->ownerNode() && cssSheet->ownerNode()->isInShadowTree())
             continue;
 
         ScopedStyleResolver* resolver = ensureScopedStyleResolver(scopingNode);
         ASSERT(resolver);
-        resolver->addRulesFromSheet(sheet, *m_medium, this);
+        resolver->addRulesFromSheet(sheet, *m_medium, this, true);
         m_inspectorCSSOMWrappers.collectFromStyleSheetIfNeeded(cssSheet);
     }
 }
 
 void StyleResolver::finishAppendAuthorStyleSheets()
 {
     collectFeatures();
 
     if (document().renderer() && document().renderer()->style())
         document().renderer()->style()->font().update(fontSelector());
 
     collectViewportRules();
+
+    document().styleEngine()->resetCSSFeatureFlags(ruleFeatureSet());
+}
+
+void StyleResolver::resetRuleFeatures()
+{
+    // Need to recreate RuleFeatureSet.
+    m_features.clear();
+    m_siblingRuleSet.clear();
+    m_uncommonAttributeRuleSet.clear();
+    m_needCollectFeatures = true;
 }
 
 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;
 
     m_ruleSets.treeBoundaryCrossingRules().reset(scopingNode);
 
     resolver->resetAuthorStyle();
+    resetRuleFeatures();
     if (!scopingNode)
         return;
 
     if (scopingNode->isInShadowTree())
         resetAtHostRules(scopingNode->containingShadowRoot());
 
     if (!resolver->hasOnlyEmptyRuleSets())
         return;
 
     m_styleTree.remove(scopingNode);
@@ skipping 29 matching lines @@
 }
 
 void StyleResolver::collectFeatures()
 {
     m_features.clear();
     m_ruleSets.collectFeaturesTo(m_features, document().isViewSource());
     m_styleTree.collectFeaturesTo(m_features);
 
     m_siblingRuleSet = makeRuleSet(m_features.siblingRules);
     m_uncommonAttributeRuleSet = makeRuleSet(m_features.uncommonAttributeRules);
+    m_needCollectFeatures = false;
 }
 
 bool StyleResolver::hasRulesForId(const AtomicString& id) const
 {
     return m_features.idsInRules.contains(id.impl());
 }
 
 void StyleResolver::addToStyleSharingList(Element* element)
 {
     if (m_styleSharingList.size() >= styleSharingListSize)
@@ skipping 317 matching lines @@
 {
     for (size_t i = 0; i < contentAttrValues.size(); ++i)
         features.attrsInRules.add(contentAttrValues[i].impl());
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderStyle* defaultParent, StyleSharingBehavior sharingBehavior,
     RuleMatchingBehavior matchingBehavior, RenderRegion* regionForStyling)
 {
     ASSERT(document().frame());
     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);
         }
         element->document().setHasNodesWithPlaceholderStyle();
@@ skipping 76 matching lines @@
         element->ensureActiveAnimations()->cssAnimations().setPendingUpdate(state.takeAnimationUpdate());
 
     // Now return the style.
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(Element* e, const RenderStyle* elementStyle, const StyleKeyframe* keyframe)
 {
     ASSERT(document().frame());
     ASSERT(documentSettings());
+    ASSERT(!hasPendingAuthorStyleSheets());
 
     if (e == document().documentElement())
         resetDirectionAndWritingModeOnDocument(document());
     StyleResolverState state(document(), e);
 
     MatchResult result;
     if (keyframe->properties())
         result.addMatchedProperties(keyframe->properties());
 
     ASSERT(!state.style());
@@ skipping 55 matching lines @@
 
 void StyleResolver::keyframeStylesForAnimation(Element* e, const RenderStyle* elementStyle, KeyframeList& list)
 {
     ASSERT(!RuntimeEnabledFeatures::webAnimationsCSSEnabled());
     list.clear();
 
     // Get the keyframesRule for this name
     if (!e || list.animationName().isEmpty())
         return;
 
+    if (hasPendingAuthorStyleSheets())
+        appendPendingAuthorStyleSheets();
+
     const StyleRuleKeyframes* keyframesRule = matchScopedKeyframesRule(e, list.animationName().impl());
     if (!keyframesRule)
         return;
 
     // Construct and populate the style for each keyframe
     const Vector<RefPtr<StyleKeyframe> >& keyframes = keyframesRule->keyframes();
     for (unsigned i = 0; i < keyframes.size(); ++i) {
         // Apply the declaration to the style. This is a simplified version of the logic in styleForElement
         const StyleKeyframe* keyframe = keyframes[i].get();
 
@@ skipping 249 matching lines @@
     }
 
     document().didAccessStyleResolver();
 
     // Now return the style.
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
 {
+    ASSERT(!hasPendingAuthorStyleSheets());
     resetDirectionAndWritingModeOnDocument(document());
     StyleResolverState state(document(), document().documentElement()); // m_rootElementStyle will be set to the document style.
 
     state.setStyle(RenderStyle::create());
     const RenderStyle* rootElementStyle = state.rootElementStyle() ? state.rootElementStyle() : document().renderStyle();
     ASSERT(rootElementStyle);
     state.style()->inheritFrom(rootElementStyle);
 
     state.fontBuilder().initForStyleResolve(state.document(), state.style(), state.useSVGZoomRules());
 
@@ skipping 522 matching lines @@
         m_matchedPropertiesSearches, m_matchedPropertiesHit, m_matchedPropertiesSharedInheritedHit, m_matchedPropertiesToCache, m_matchedPropertiesEnteredIntoCache);
 
     fprintf(stderr, "Total:\n");
     printStyleStats(m_totalSearches, m_totalElementsEligibleForSharing, m_totalStylesShared, m_totalSearchFoundSiblingForSharing, m_totalSearchesMissedSharing,
         m_totalMatchedPropertiesSearches, m_totalMatchedPropertiesHit, m_totalMatchedPropertiesSharedInheritedHit, m_totalMatchedPropertiesToCache, m_totalMatchedPropertiesEnteredIntoCache);
     fprintf(stderr, "--------------------------------------------------------------------------------\n");
 }
 #endif
 
 } // namespace WebCore