Changeset 163592 in webkit

Timestamp:

Feb 6, 2014 5:58:40 PM (10 years ago)

Author:

Antti Koivisto

Message:

Check selectors exactly when invalidating style
​https://bugs.webkit.org/show_bug.cgi?id=128321

Reviewed by Andreas Kling.

Selectors are now really fast to match with the JIT. Take advantage of this by invalidating
the document style exactly when a new stylesheet arrives (instead of using heuristics).

This reduces need for large style recalculations in some common cases.

• css/ElementRuleCollector.cpp:

(WebCore::ElementRuleCollector::clearMatchedRules):
(WebCore::ElementRuleCollector::collectMatchingRulesForList):

• css/ElementRuleCollector.h:

(WebCore::ElementRuleCollector::hasMatchedRules):

• css/RuleSet.h:

(WebCore::RuleSet::hasShadowPseudoElementRules):

• css/SelectorChecker.cpp:

(WebCore::SelectorChecker::matchRecursively):

• css/SelectorChecker.h:

Add new mode where all pseudo elements match so we can invalidate their element.

• css/StyleInvalidationAnalysis.cpp:

(WebCore::shouldDirtyAllStyle):
(WebCore::StyleInvalidationAnalysis::StyleInvalidationAnalysis):
(WebCore::invalidateStyleRecursively):
(WebCore::StyleInvalidationAnalysis::invalidateStyle):

Switch to real selector checker.

• css/StyleInvalidationAnalysis.h:
• css/StyleResolver.cpp:

(WebCore::StyleResolver::MatchedProperties::~MatchedProperties):

• css/StyleResolver.h:

(WebCore::StyleResolver::mediaQueryEvaluator):

• dom/DocumentStyleSheetCollection.cpp:

(WebCore::DocumentStyleSheetCollection::analyzeStyleSheetChange):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/ElementRuleCollector.cpp (modified) (2 diffs)
• css/ElementRuleCollector.h (modified) (2 diffs)
• css/RuleSet.h (modified) (1 diff)
• css/SelectorChecker.cpp (modified) (3 diffs)
• css/SelectorChecker.h (modified) (1 diff)
• css/StyleInvalidationAnalysis.cpp (modified) (3 diffs)
• css/StyleInvalidationAnalysis.h (modified) (4 diffs)
• css/StyleResolver.cpp (modified) (1 diff)
• css/StyleResolver.h (modified) (1 diff)
• dom/DocumentStyleSheetCollection.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2014-02-06  Antti Koivisto  <antti@apple.com>
+
+        Check selectors exactly when invalidating style
+        https://bugs.webkit.org/show_bug.cgi?id=128321
+
+        Reviewed by Andreas Kling.
+        
+        Selectors are now really fast to match with the JIT. Take advantage of this by invalidating
+        the document style exactly when a new stylesheet arrives (instead of using heuristics).
+        
+        This reduces need for large style recalculations in some common cases.
+
+        * css/ElementRuleCollector.cpp:
+        (WebCore::ElementRuleCollector::clearMatchedRules):
+        (WebCore::ElementRuleCollector::collectMatchingRulesForList):
+        * css/ElementRuleCollector.h:
+        (WebCore::ElementRuleCollector::hasMatchedRules):
+        * css/RuleSet.h:
+        (WebCore::RuleSet::hasShadowPseudoElementRules):
+        * css/SelectorChecker.cpp:
+        (WebCore::SelectorChecker::matchRecursively):
+        * css/SelectorChecker.h:
+        
+            Add new mode where all pseudo elements match so we can invalidate their element.
+
+        * css/StyleInvalidationAnalysis.cpp:
+        (WebCore::shouldDirtyAllStyle):
+        (WebCore::StyleInvalidationAnalysis::StyleInvalidationAnalysis):
+        (WebCore::invalidateStyleRecursively):
+        (WebCore::StyleInvalidationAnalysis::invalidateStyle):
+        
+            Switch to real selector checker.
+
+        * css/StyleInvalidationAnalysis.h:
+        * css/StyleResolver.cpp:
+        (WebCore::StyleResolver::MatchedProperties::~MatchedProperties):
+        * css/StyleResolver.h:
+        (WebCore::StyleResolver::mediaQueryEvaluator):
+        * dom/DocumentStyleSheetCollection.cpp:
+        (WebCore::DocumentStyleSheetCollection::analyzeStyleSheetChange):
+
 2014-02-06  Gavin Barraclough  <barraclough@apple.com>
 

trunk/Source/WebCore/css/ElementRuleCollector.cpp

@@ -95 +95 @@
 }
 
-inline void ElementRuleCollector::clearMatchedRules()
+void ElementRuleCollector::clearMatchedRules()
 {
     if (!m_matchedRules)
@@ -360 +360 @@
         if (ruleMatches(ruleData, dynamicPseudo)) {
             // For SharingRules testing, any match is good enough, we don't care what is matched.
-            if (m_mode == SelectorChecker::SharingRules) {
+            if (m_mode == SelectorChecker::SharingRules || m_mode == SelectorChecker::StyleInvalidation) {
                 addMatchedRule(&ruleData);
                 break;

trunk/Source/WebCore/css/ElementRuleCollector.h

@@ -71 +71 @@
     const Vector<RefPtr<StyleRuleBase>>& matchedRuleList() const;
 
+    bool hasMatchedRules() const { return m_matchedRules && !m_matchedRules->isEmpty(); }
+    void clearMatchedRules();
+
 private:
     void addElementStyleProperties(const StyleProperties*, bool isCacheable = true);
@@ -85 +88 @@
 
     void addMatchedRule(const RuleData*);
-    void clearMatchedRules();
 
     Element& m_element;

trunk/Source/WebCore/css/RuleSet.h

@@ -167 +167 @@
     unsigned ruleCount() const { return m_ruleCount; }
 
+    bool hasShadowPseudoElementRules() const { return !m_shadowPseudoElementRules.isEmpty(); }
+
 private:
     void addChildRules(const Vector<RefPtr<StyleRuleBase>>&, const MediaQueryEvaluator& medium, StyleResolver*, bool hasDocumentSecurityOrigin, AddRuleFlags);

trunk/Source/WebCore/css/SelectorChecker.cpp

@@ -3 +3 @@
  *           (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) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
@@ -163 +163 @@
                 if (context.selector->pseudoType() == CSSSelector::PseudoWebKitCustomElement && root->type() != ShadowRoot::UserAgentShadowRoot)
                     return SelectorFailsLocally;
-            } else
+            } else if (m_mode != StyleInvalidation)
                 return SelectorFailsLocally;
         } else {
@@ -169 +169 @@
                 return SelectorFailsLocally;
 
-            PseudoId pseudoId = CSSSelector::pseudoId(context.selector->pseudoType());
+            // When invalidating style all pseudo elements need to match.
+            PseudoId pseudoId = m_mode == StyleInvalidation ? NOPSEUDO : CSSSelector::pseudoId(context.selector->pseudoType());
             if (pseudoId == FIRST_LETTER)
                 context.element->document().styleSheetCollection().setUsesFirstLetterRules(true);

trunk/Source/WebCore/css/SelectorChecker.h

@@ -48 +48 @@
 public:
     enum VisitedMatchType { VisitedMatchDisabled, VisitedMatchEnabled };
-    enum Mode { ResolvingStyle = 0, CollectingRules, QueryingRules, SharingRules };
+    enum Mode { ResolvingStyle = 0, CollectingRules, QueryingRules, SharingRules, StyleInvalidation };
 
     SelectorChecker(Document&, Mode);

trunk/Source/WebCore/css/StyleInvalidationAnalysis.cpp

@@ -1 +1 @@
 /*
- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30 +30 @@
 #include "Document.h"
 #include "ElementIterator.h"
+#include "ElementRuleCollector.h"
+#include "SelectorFilter.h"
 #include "StyleRuleImport.h"
 #include "StyleSheetContents.h"
-#include "StyledElement.h"
 
 namespace WebCore {
 
-StyleInvalidationAnalysis::StyleInvalidationAnalysis(const Vector<StyleSheetContents*>& sheets)
-    : m_dirtiesAllStyle(false)
+static bool shouldDirtyAllStyle(const Vector<RefPtr<StyleRuleBase>> rules)
 {
-    for (unsigned i = 0; i < sheets.size() && !m_dirtiesAllStyle; ++i)
-        analyzeStyleSheet(sheets[i]);
-}
-
-static bool determineSelectorScopes(const CSSSelectorList& selectorList, HashSet<AtomicStringImpl*>& idScopes, HashSet<AtomicStringImpl*>& classScopes)
-{
-    for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
-        const CSSSelector* scopeSelector = 0;
-        // This picks the widest scope, not the narrowest, to minimize the number of found scopes.
-        for (const CSSSelector* current = selector; current; current = current->tagHistory()) {
-            // Prefer ids over classes.
-            if (current->m_match == CSSSelector::Id)
-                scopeSelector = current;
-            else if (current->m_match == CSSSelector::Class && (!scopeSelector || scopeSelector->m_match != CSSSelector::Id))
-                scopeSelector = current;
-            CSSSelector::Relation relation = current->relation();
-            if (relation != CSSSelector::Descendant && relation != CSSSelector::Child && relation != CSSSelector::SubSelector)
-                break;
+    for (auto& rule : rules) {
+        if (rule->isMediaRule()) {
+            if (shouldDirtyAllStyle(static_cast<StyleRuleMedia&>(*rule).childRules()))
+                return true;
+            continue;
         }
-        if (!scopeSelector)
-            return false;
-        ASSERT(scopeSelector->m_match == CSSSelector::Class || scopeSelector->m_match == CSSSelector::Id);
-        if (scopeSelector->m_match == CSSSelector::Id)
-            idScopes.add(scopeSelector->value().impl());
-        else
-            classScopes.add(scopeSelector->value().impl());
-    }
-    return true;
-}
-
-void StyleInvalidationAnalysis::analyzeStyleSheet(StyleSheetContents* styleSheetContents)
-{
-    ASSERT(!styleSheetContents->isLoading());
-
-    // See if all rules on the sheet are scoped to some specific ids or classes.
-    // Then test if we actually have any of those in the tree at the moment.
-    const Vector<RefPtr<StyleRuleImport>>& importRules = styleSheetContents->importRules();
-    for (unsigned i = 0; i < importRules.size(); ++i) {
-        if (!importRules[i]->styleSheet())
-            continue;
-        analyzeStyleSheet(importRules[i]->styleSheet());
-        if (m_dirtiesAllStyle)
-            return;
-    }
-    const Vector<RefPtr<StyleRuleBase>>& rules = styleSheetContents->childRules();
-    for (unsigned i = 0; i < rules.size(); i++) {
-        StyleRuleBase* rule = rules[i].get();
-        if (!rule->isStyleRule()) {
-            // FIXME: Media rules and maybe some others could be allowed.
-            m_dirtiesAllStyle = true;
-            return;
-        }
-        StyleRule* styleRule = static_cast<StyleRule*>(rule);
-        if (!determineSelectorScopes(styleRule->selectorList(), m_idScopes, m_classScopes)) {
-            m_dirtiesAllStyle = true;
-            return;
-        }
-    }
-}
-
-static bool elementMatchesSelectorScopes(const Element& element, const HashSet<AtomicStringImpl*>& idScopes, const HashSet<AtomicStringImpl*>& classScopes)
-{
-    if (!idScopes.isEmpty() && element.hasID() && idScopes.contains(element.idForStyleResolution().impl()))
-        return true;
-    if (classScopes.isEmpty() || !element.hasClass())
-        return false;
-    const SpaceSplitString& classNames = element.classNames();
-    for (unsigned i = 0; i < classNames.size(); ++i) {
-        if (classScopes.contains(classNames[i].impl()))
+        // FIXME: At least font faces don't need full recalc in all cases.
+        if (!rule->isStyleRule())
             return true;
     }
@@ -113 +52 @@
 }
 
+static bool shouldDirtyAllStyle(const StyleSheetContents& sheet)
+{
+    for (auto& import : sheet.importRules()) {
+        if (!import->styleSheet())
+            continue;
+        if (shouldDirtyAllStyle(*import->styleSheet()))
+            return true;
+    }
+    if (shouldDirtyAllStyle(sheet.childRules()))
+        return true;
+    return false;
+}
+
+static bool shouldDirtyAllStyle(const Vector<StyleSheetContents*>& sheets)
+{
+    for (auto& sheet : sheets) {
+        if (shouldDirtyAllStyle(*sheet))
+            return true;
+    }
+    return false;
+}
+
+StyleInvalidationAnalysis::StyleInvalidationAnalysis(const Vector<StyleSheetContents*>& sheets, const MediaQueryEvaluator& mediaQueryEvaluator)
+    : m_dirtiesAllStyle(shouldDirtyAllStyle(sheets))
+{
+    if (m_dirtiesAllStyle)
+        return;
+
+    m_ruleSets.resetAuthorStyle();
+    for (auto& sheet : sheets)
+        m_ruleSets.authorStyle()->addRulesFromSheet(sheet, mediaQueryEvaluator);
+
+    // FIXME: We don't descent into shadow trees or otherwise handle shadow pseudo elements.
+    if (m_ruleSets.authorStyle()->hasShadowPseudoElementRules())
+        m_dirtiesAllStyle = true;
+}
+
+static void invalidateStyleRecursively(Element& element, SelectorFilter& filter, const DocumentRuleSets& ruleSets)
+{
+    if (element.styleChangeType() > InlineStyleChange)
+        return;
+    if (element.styleChangeType() == NoStyleChange) {
+        ElementRuleCollector ruleCollector(element, nullptr, ruleSets, filter);
+        ruleCollector.setMode(SelectorChecker::StyleInvalidation);
+        ruleCollector.matchAuthorRules(false);
+
+        if (ruleCollector.hasMatchedRules())
+            element.setNeedsStyleRecalc(InlineStyleChange);
+    }
+
+    auto children = childrenOfType<Element>(element);
+    if (!children.first())
+        return;
+    filter.pushParent(&element);
+    for (auto& child : children)
+        invalidateStyleRecursively(child, filter, ruleSets);
+    filter.popParent();
+}
+
 void StyleInvalidationAnalysis::invalidateStyle(Document& document)
 {
     ASSERT(!m_dirtiesAllStyle);
-    if (m_idScopes.isEmpty() && m_classScopes.isEmpty())
+    if (!m_ruleSets.authorStyle())
         return;
 
-    auto it = descendantsOfType<Element>(document).begin();
-    auto end = descendantsOfType<Element>(document).end();
-    while (it != end) {
-        if (elementMatchesSelectorScopes(*it, m_idScopes, m_classScopes)) {
-            it->setNeedsStyleRecalc();
-            // The whole subtree is now invalidated, we can skip to the next sibling.
-            it.traverseNextSkippingChildren();
-            continue;
-        }
-        ++it;
-    }
+    Element* documentElement = document.documentElement();
+    if (!documentElement)
+        return;
+
+    SelectorFilter filter;
+    filter.setupParentStack(documentElement);
+    invalidateStyleRecursively(*documentElement, filter, m_ruleSets);
 }
 

trunk/Source/WebCore/css/StyleInvalidationAnalysis.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27 +27 @@
 #define StyleInvalidationAnalysis_h
 
+#include "DocumentRuleSets.h"
 #include <wtf/HashSet.h>
 #include <wtf/text/AtomicStringImpl.h>
@@ -37 +38 @@
 class StyleInvalidationAnalysis {
 public:
-    StyleInvalidationAnalysis(const Vector<StyleSheetContents*>&);
+    StyleInvalidationAnalysis(const Vector<StyleSheetContents*>&, const MediaQueryEvaluator&);
 
     bool dirtiesAllStyle() const { return m_dirtiesAllStyle; }
@@ -43 +44 @@
 
 private:
-
-    void analyzeStyleSheet(StyleSheetContents*);
-
     bool m_dirtiesAllStyle;
-    HashSet<AtomicStringImpl*> m_idScopes;
-    HashSet<AtomicStringImpl*> m_classScopes;
+    DocumentRuleSets m_ruleSets;
 };
 

trunk/Source/WebCore/css/StyleResolver.cpp

@@ -3658 +3658 @@
 }
 
-inline StyleResolver::MatchedProperties::~MatchedProperties()
+StyleResolver::MatchedProperties::~MatchedProperties()
 {
 }

trunk/Source/WebCore/css/StyleResolver.h

@@ -169 +169 @@
     SelectorFilter& selectorFilter() { return m_selectorFilter; }
 
+    const MediaQueryEvaluator& mediaQueryEvaluator() const { return *m_medium; }
+
 private:
     void initElement(Element*);

trunk/Source/WebCore/dom/DocumentStyleSheetCollection.cpp

@@ -367 +367 @@
     if (!m_document.styleResolverIfExists())
         return;
+    StyleResolver& styleResolver = *m_document.styleResolverIfExists();
 
     // Find out which stylesheets are new.
@@ -397 +398 @@
     if (!m_document.body() || m_document.hasNodesWithPlaceholderStyle())
         return;
-    StyleInvalidationAnalysis invalidationAnalysis(addedSheets);
+    StyleInvalidationAnalysis invalidationAnalysis(addedSheets, styleResolver.mediaQueryEvaluator());
     if (invalidationAnalysis.dirtiesAllStyle())
         return;