Move Document global rule data to CSSGlobalRuleSet.

third_party/WebKit/Source/core/dom/StyleEngine.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
@@ skipping 19 matching lines @@
 #include "core/dom/StyleEngine.h"
 
 #include "core/HTMLNames.h"
 #include "core/css/CSSDefaultStyleSheets.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/FontFaceCache.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/invalidation/InvalidationSet.h"
 #include "core/css/resolver/ScopedStyleResolver.h"
+#include "core/css/resolver/SharedStyleFinder.h"
 #include "core/css/resolver/ViewportStyleResolver.h"
 #include "core/dom/DocumentStyleSheetCollector.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ProcessingInstruction.h"
 #include "core/dom/ShadowTreeStyleSheetCollection.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/html/HTMLSlotElement.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/inspector/InspectorInstrumentation.h"
+#include "core/layout/api/LayoutViewItem.h"
 #include "core/page/Page.h"
 #include "core/svg/SVGStyleElement.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/tracing/TraceEvent.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 StyleEngine::StyleEngine(Document& document)
@@ skipping 55 matching lines @@
 
 const HeapVector<TraceWrapperMember<StyleSheet>>&
 StyleEngine::styleSheetsForStyleSheetList(TreeScope& treeScope) {
   if (treeScope == m_document)
     return documentStyleSheetCollection().styleSheetsForStyleSheetList();
 
   return ensureStyleSheetCollectionFor(treeScope)
       ->styleSheetsForStyleSheetList();
 }
 
-void StyleEngine::resetCSSFeatureFlags(const RuleFeatureSet& features) {
-  m_usesSiblingRules = features.usesSiblingRules();
-  m_usesFirstLineRules = features.usesFirstLineRules();
-  m_usesWindowInactiveSelector = features.usesWindowInactiveSelector();
-  m_maxDirectAdjacentSelectors = features.maxDirectAdjacentSelectors();
-}
-
 void StyleEngine::injectAuthorSheet(StyleSheetContents* authorSheet) {
   m_injectedAuthorStyleSheets.append(
       CSSStyleSheet::create(authorSheet, *m_document));
   markDocumentDirty();
   resolverChanged(AnalyzedStyleUpdate);
 }
 
 CSSStyleSheet& StyleEngine::ensureInspectorStyleSheet() {
   if (m_inspectorStyleSheet)
     return *m_inspectorStyleSheet;
@@ skipping 102 matching lines @@
   if (!node.isConnected())
     return;
 
   TreeScope& treeScope = isStyleElement(node) ? node.treeScope() : *m_document;
   DCHECK(isStyleElement(node) || treeScope == m_document);
   markTreeScopeDirty(treeScope);
   resolverChanged(AnalyzedStyleUpdate);
 }
 
 void StyleEngine::watchedSelectorsChanged() {
-  if (m_resolver) {
-    m_resolver->initWatchedSelectorRules();
-    m_resolver->resetRuleFeatures();
-  }
+  m_globalRuleSet.initWatchedSelectorsRuleSet(document());
+  // TODO(rune@opera.com): Should be able to use RuleSetInvalidation here.
   document().setNeedsStyleRecalc(SubtreeStyleChange,
                                  StyleChangeReasonForTracing::create(
                                      StyleChangeReason::DeclarativeContent));
 }
 
 bool StyleEngine::shouldUpdateDocumentStyleSheetCollection(
     StyleResolverUpdateMode updateMode) const {
   return m_documentScopeDirty || updateMode == FullStyleUpdate;
 }
 
@@ skipping 118 matching lines @@
   m_treeBoundaryCrossingScopes.add(&treeScope.rootNode());
 }
 
 void StyleEngine::resetAuthorStyle(TreeScope& treeScope) {
   m_treeBoundaryCrossingScopes.remove(&treeScope.rootNode());
 
   ScopedStyleResolver* scopedResolver = treeScope.scopedStyleResolver();
   if (!scopedResolver)
     return;
 
-  DCHECK(m_resolver);
-  m_resolver->resetRuleFeatures();
+  m_globalRuleSet.markDirty();
   if (treeScope.rootNode().isDocumentNode()) {
     scopedResolver->resetAuthorStyle();
     return;
   }
 
   treeScope.clearScopedStyleResolver();
 }
 
+void StyleEngine::finishAppendAuthorStyleSheets() {
+  m_globalRuleSet.markDirty();
+  m_globalRuleSet.update(document());
+
+  if (!document().layoutViewItem().isNull() &&
+      document().layoutViewItem().style())
+    document().layoutViewItem().style()->font().update(fontSelector());
+}
+
 void StyleEngine::appendActiveAuthorStyleSheets() {
   DCHECK(isMaster());
 
   viewportRulesChanged();
 
   m_resolver->appendAuthorStyleSheets(
       documentStyleSheetCollection().activeAuthorStyleSheets());
   for (TreeScope* treeScope : m_activeTreeScopes) {
     if (TreeScopeStyleSheetCollection* collection =
             m_styleSheetCollectionMap.get(treeScope))
       m_resolver->appendAuthorStyleSheets(
           collection->activeAuthorStyleSheets());
   }
-  m_resolver->finishAppendAuthorStyleSheets();
 }
 
 void StyleEngine::createResolver() {
   m_resolver = StyleResolver::create(*m_document);
 
   // A scoped style resolver for document will be created during
   // appendActiveAuthorStyleSheets if needed.
   appendActiveAuthorStyleSheets();
+  finishAppendAuthorStyleSheets();
 }
 
 void StyleEngine::clearResolver() {
   DCHECK(!document().inStyleRecalc());
   DCHECK(isMaster() || !m_resolver);
 
   document().clearScopedStyleResolver();
   // TODO(rune@opera.com): The clearing of all shadow tree scoped style
   // resolvers below should not be necessary. It was introduced to fix a crash
   // bug (https://crbug.com/447976) when clearResolver is called from didDetach
@@ skipping 201 matching lines @@
     return true;
   return element.parentNode()->getStyleChangeType() >= SubtreeStyleChange;
 }
 
 void StyleEngine::classChangedForElement(const SpaceSplitString& changedClasses,
                                          Element& element) {
   if (shouldSkipInvalidationFor(element))
     return;
   InvalidationLists invalidationLists;
   unsigned changedSize = changedClasses.size();
-  RuleFeatureSet& ruleFeatureSet =
-      ensureResolver().ensureUpdatedRuleFeatureSet();
-  for (unsigned i = 0; i < changedSize; ++i)
-    ruleFeatureSet.collectInvalidationSetsForClass(invalidationLists, element,
-                                                   changedClasses[i]);
+  // TODO(rune@opera.com): ensureResolver() can be removed once stylesheet
+  // updates are async. https://crbug.com/567021
+  ensureResolver();
+  const RuleFeatureSet& features = ruleFeatureSet();
+  for (unsigned i = 0; i < changedSize; ++i) {
+    features.collectInvalidationSetsForClass(invalidationLists, element,
+                                             changedClasses[i]);
+  }
   m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists,
                                                      element);
 }
 
 void StyleEngine::classChangedForElement(const SpaceSplitString& oldClasses,
                                          const SpaceSplitString& newClasses,
                                          Element& element) {
   if (shouldSkipInvalidationFor(element))
     return;
 
   if (!oldClasses.size()) {
     classChangedForElement(newClasses, element);
     return;
   }
 
   // Class vectors tend to be very short. This is faster than using a hash
   // table.
   BitVector remainingClassBits;
   remainingClassBits.ensureSize(oldClasses.size());
 
   InvalidationLists invalidationLists;
-  RuleFeatureSet& ruleFeatureSet =
-      ensureResolver().ensureUpdatedRuleFeatureSet();
+  // TODO(rune@opera.com): ensureResolver() can be removed once stylesheet
+  // updates are async. https://crbug.com/567021
+  ensureResolver();
+  const RuleFeatureSet& features = ruleFeatureSet();
 
   for (unsigned i = 0; i < newClasses.size(); ++i) {
     bool found = false;
     for (unsigned j = 0; j < oldClasses.size(); ++j) {
       if (newClasses[i] == oldClasses[j]) {
         // Mark each class that is still in the newClasses so we can skip doing
         // an n^2 search below when looking for removals. We can't break from
         // this loop early since a class can appear more than once.
         remainingClassBits.quickSet(j);
         found = true;
       }
     }
     // Class was added.
-    if (!found)
-      ruleFeatureSet.collectInvalidationSetsForClass(invalidationLists, element,
-                                                     newClasses[i]);
+    if (!found) {
+      features.collectInvalidationSetsForClass(invalidationLists, element,
+                                               newClasses[i]);
+    }
   }
 
   for (unsigned i = 0; i < oldClasses.size(); ++i) {
     if (remainingClassBits.quickGet(i))
       continue;
     // Class was removed.
-    ruleFeatureSet.collectInvalidationSetsForClass(invalidationLists, element,
-                                                   oldClasses[i]);
+    features.collectInvalidationSetsForClass(invalidationLists, element,
+                                             oldClasses[i]);
   }
 
   m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists,
                                                      element);
 }
 
 void StyleEngine::attributeChangedForElement(const QualifiedName& attributeName,
                                              Element& element) {
   if (shouldSkipInvalidationFor(element))
     return;
 
   InvalidationLists invalidationLists;
-  ensureResolver()
-      .ensureUpdatedRuleFeatureSet()
-      .collectInvalidationSetsForAttribute(invalidationLists, element,
-                                           attributeName);
+  // TODO(rune@opera.com): ensureResolver() can be removed once stylesheet
+  // updates are async. https://crbug.com/567021
+  ensureResolver();
+  ruleFeatureSet().collectInvalidationSetsForAttribute(invalidationLists,
+                                                       element, attributeName);
   m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists,
                                                      element);
 }
 
 void StyleEngine::idChangedForElement(const AtomicString& oldId,
                                       const AtomicString& newId,
                                       Element& element) {
   if (shouldSkipInvalidationFor(element))
     return;
 
   InvalidationLists invalidationLists;
-  RuleFeatureSet& ruleFeatureSet =
-      ensureResolver().ensureUpdatedRuleFeatureSet();
+  // TODO(rune@opera.com): ensureResolver() can be removed once stylesheet
+  // updates are async. https://crbug.com/567021
+  ensureResolver();
+  const RuleFeatureSet& features = ruleFeatureSet();
   if (!oldId.isEmpty())
-    ruleFeatureSet.collectInvalidationSetsForId(invalidationLists, element,
-                                                oldId);
+    features.collectInvalidationSetsForId(invalidationLists, element, oldId);
   if (!newId.isEmpty())
-    ruleFeatureSet.collectInvalidationSetsForId(invalidationLists, element,
-                                                newId);
+    features.collectInvalidationSetsForId(invalidationLists, element, newId);
   m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists,
                                                      element);
 }
 
 void StyleEngine::pseudoStateChangedForElement(
     CSSSelector::PseudoType pseudoType,
     Element& element) {
   if (shouldSkipInvalidationFor(element))
     return;
 
   InvalidationLists invalidationLists;
-  ensureResolver()
-      .ensureUpdatedRuleFeatureSet()
-      .collectInvalidationSetsForPseudoClass(invalidationLists, element,
-                                             pseudoType);
+  // TODO(rune@opera.com): ensureResolver() can be removed once stylesheet
+  // updates are async. https://crbug.com/567021
+  ensureResolver();
+  ruleFeatureSet().collectInvalidationSetsForPseudoClass(invalidationLists,
+                                                         element, pseudoType);
   m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists,
                                                      element);
 }
 
 void StyleEngine::scheduleSiblingInvalidationsForElement(
     Element& element,
     ContainerNode& schedulingParent,
     unsigned minDirectAdjacent) {
   DCHECK(minDirectAdjacent);
 
   InvalidationLists invalidationLists;
 
-  RuleFeatureSet& ruleFeatureSet =
-      ensureResolver().ensureUpdatedRuleFeatureSet();
+  // TODO(rune@opera.com): ensureResolver() can be removed once stylesheet
+  // updates are async. https://crbug.com/567021
+  ensureResolver();
+  const RuleFeatureSet& features = ruleFeatureSet();
 
-  if (element.hasID())
-    ruleFeatureSet.collectSiblingInvalidationSetForId(
-        invalidationLists, element, element.idForStyleResolution(),
-        minDirectAdjacent);
+  if (element.hasID()) {
+    features.collectSiblingInvalidationSetForId(invalidationLists, element,
+                                                element.idForStyleResolution(),
+                                                minDirectAdjacent);
+  }
 
   if (element.hasClass()) {
     const SpaceSplitString& classNames = element.classNames();
     for (size_t i = 0; i < classNames.size(); i++)
-      ruleFeatureSet.collectSiblingInvalidationSetForClass(
+      features.collectSiblingInvalidationSetForClass(
           invalidationLists, element, classNames[i], minDirectAdjacent);
   }
 
   for (const Attribute& attribute : element.attributes())
-    ruleFeatureSet.collectSiblingInvalidationSetForAttribute(
+    features.collectSiblingInvalidationSetForAttribute(
         invalidationLists, element, attribute.name(), minDirectAdjacent);
 
-  ruleFeatureSet.collectUniversalSiblingInvalidationSet(invalidationLists,
-                                                        minDirectAdjacent);
+  features.collectUniversalSiblingInvalidationSet(invalidationLists,
+                                                  minDirectAdjacent);
 
   m_styleInvalidator.scheduleSiblingInvalidationsAsDescendants(
       invalidationLists, schedulingParent);
 }
 
 void StyleEngine::scheduleInvalidationsForInsertedSibling(
     Element* beforeElement,
     Element& insertedElement) {
   unsigned affectedSiblings =
       insertedElement.parentNode()->childrenAffectedByIndirectAdjacentRules()
           ? UINT_MAX
-          : m_maxDirectAdjacentSelectors;
+          : maxDirectAdjacentSelectors();
 
   ContainerNode* schedulingParent = insertedElement.parentElementOrShadowRoot();
   if (!schedulingParent)
     return;
 
   scheduleSiblingInvalidationsForElement(insertedElement, *schedulingParent, 1);
 
   for (unsigned i = 1; beforeElement && i <= affectedSiblings;
        i++, beforeElement = ElementTraversal::previousSibling(*beforeElement))
     scheduleSiblingInvalidationsForElement(*beforeElement, *schedulingParent,
                                            i);
 }
 
 void StyleEngine::scheduleInvalidationsForRemovedSibling(
     Element* beforeElement,
     Element& removedElement,
     Element& afterElement) {
   unsigned affectedSiblings =
       afterElement.parentNode()->childrenAffectedByIndirectAdjacentRules()
           ? UINT_MAX
-          : m_maxDirectAdjacentSelectors;
+          : maxDirectAdjacentSelectors();
 
   ContainerNode* schedulingParent = afterElement.parentElementOrShadowRoot();
   if (!schedulingParent)
     return;
 
   scheduleSiblingInvalidationsForElement(removedElement, *schedulingParent, 1);
 
   for (unsigned i = 1; beforeElement && i <= affectedSiblings;
        i++, beforeElement = ElementTraversal::previousSibling(*beforeElement))
     scheduleSiblingInvalidationsForElement(*beforeElement, *schedulingParent,
                                            i);
 }
 
 void StyleEngine::scheduleNthPseudoInvalidations(ContainerNode& nthParent) {
   InvalidationLists invalidationLists;
-  ensureResolver().ensureUpdatedRuleFeatureSet().collectNthInvalidationSet(
-      invalidationLists);
+  // TODO(rune@opera.com): ensureResolver() can be removed once stylesheet
+  // updates are async. https://crbug.com/567021
+  ensureResolver();
+  ruleFeatureSet().collectNthInvalidationSet(invalidationLists);
   m_styleInvalidator.scheduleInvalidationSetsForNode(invalidationLists,
                                                      nthParent);
 }
 
 void StyleEngine::scheduleRuleSetInvalidationsForElement(
     Element& element,
     const HeapVector<Member<RuleSet>>& ruleSets) {
   AtomicString id;
   const SpaceSplitString* classNames = nullptr;
 
@@ skipping 111 matching lines @@
   // has no other effect than the ability to read back the set value using
   // the same api. If it did have an effect, we should have marked the
   // document scope dirty and triggered an update of the active stylesheets
   // from here.
 }
 
 void StyleEngine::setHttpDefaultStyle(const String& content) {
   setPreferredStylesheetSetNameIfNotSet(content, UpdateActiveSheets);
 }
 
-void StyleEngine::ensureFullscreenUAStyle() {
+void StyleEngine::ensureUAStyleForFullscreen() {
+  if (m_globalRuleSet.hasFullscreenUAStyle())
+    return;
   CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetForFullscreen();
-  if (!m_resolver)
-    return;
-  if (!m_resolver->hasFullscreenUAStyle())
-    m_resolver->resetRuleFeatures();
+  m_globalRuleSet.markDirty();
+  m_globalRuleSet.update(document());
+}
+
+void StyleEngine::ensureUAStyleForElement(const Element& element) {
+  if (CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(
+          element)) {
+    m_globalRuleSet.markDirty();
+    m_globalRuleSet.update(document());
+  }
+}
+
+bool StyleEngine::hasRulesForId(const AtomicString& id) const {
+  return m_globalRuleSet.ruleFeatureSet().hasSelectorForId(id);
 }
 
 void StyleEngine::initialViewportChanged() {
   if (!m_viewportResolver)
     return;
 
   m_viewportResolver->initialViewportChanged();
 
   // TODO(rune@opera.com): for async stylesheet update, updateViewport() should
   // be called as part of the lifecycle update for active style. Synchronous for
   // now.
   m_viewportResolver->updateViewport(documentStyleSheetCollection());
 }
 
 void StyleEngine::viewportRulesChanged() {
   if (!m_viewportResolver)
     return;
   m_viewportResolver->setNeedsCollectRules();
 
   // TODO(rune@opera.com): for async stylesheet update, updateViewport() should
   // be called as part of the lifecycle update for active style. Synchronous for
   // now.
   m_viewportResolver->updateViewport(documentStyleSheetCollection());
 }
 
+PassRefPtr<ComputedStyle> StyleEngine::findSharedStyle(
+    const ElementResolveContext& elementResolveContext) {
+  DCHECK(m_resolver);
+  return SharedStyleFinder(
+             elementResolveContext, m_globalRuleSet.ruleFeatureSet(),
+             m_globalRuleSet.siblingRuleSet(),
+             m_globalRuleSet.uncommonAttributeRuleSet(), *m_resolver)
+      .findSharedStyle();
+}
+
 DEFINE_TRACE(StyleEngine) {
   visitor->trace(m_document);
   visitor->trace(m_injectedAuthorStyleSheets);
   visitor->trace(m_inspectorStyleSheet);
   visitor->trace(m_documentStyleSheetCollection);
   visitor->trace(m_styleSheetCollectionMap);
+  visitor->trace(m_dirtyTreeScopes);
+  visitor->trace(m_activeTreeScopes);
+  visitor->trace(m_treeBoundaryCrossingScopes);
+  visitor->trace(m_globalRuleSet);
   visitor->trace(m_resolver);
   visitor->trace(m_viewportResolver);
   visitor->trace(m_styleInvalidator);
-  visitor->trace(m_dirtyTreeScopes);
-  visitor->trace(m_activeTreeScopes);
-  visitor->trace(m_treeBoundaryCrossingScopes);
   visitor->trace(m_fontSelector);
   visitor->trace(m_textToSheetCache);
   visitor->trace(m_sheetToTextCache);
   CSSFontSelectorClient::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(StyleEngine) {
   for (auto sheet : m_injectedAuthorStyleSheets) {
     visitor->traceWrappers(sheet);
   }
   visitor->traceWrappers(m_documentStyleSheetCollection);
 }
 
 }  // namespace blink