Move Document global rule data to CSSGlobalRuleSet.

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

 /*
  * 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, 2010, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
@@ skipping 16 matching lines @@
  *
  */
 
 #ifndef StyleEngine_h
 #define StyleEngine_h
 
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "bindings/core/v8/TraceWrapperMember.h"
 #include "core/CoreExport.h"
 #include "core/css/CSSFontSelectorClient.h"
+#include "core/css/CSSGlobalRuleSet.h"
 #include "core/css/invalidation/StyleInvalidator.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/css/resolver/StyleResolverStats.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentOrderedList.h"
 #include "core/dom/DocumentStyleSheetCollection.h"
 #include "core/dom/StyleEngineContext.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Allocator.h"
 #include "wtf/AutoReset.h"
@@ skipping 54 matching lines @@
   void addStyleSheetCandidateNode(Node&);
   void removeStyleSheetCandidateNode(Node&);
   void removeStyleSheetCandidateNode(Node&, TreeScope&);
   void modifiedStyleSheetCandidateNode(Node&);
   void watchedSelectorsChanged();
   void initialViewportChanged();
   void viewportRulesChanged();
 
   void injectAuthorSheet(StyleSheetContents* authorSheet);
   CSSStyleSheet& ensureInspectorStyleSheet();
+  RuleSet* watchedSelectorsRuleSet() {
+    return m_globalRuleSet.watchedSelectorsRuleSet();
+  }
 
   void clearMediaQueryRuleSetStyleSheets();
   void updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector);
   void updateActiveStyleSheets(StyleResolverUpdateMode);
 
   enum ActiveSheetsUpdate { DontUpdateActiveSheets, UpdateActiveSheets };
   String preferredStylesheetSetName() const {
     return m_preferredStylesheetSetName;
   }
   String selectedStylesheetSetName() const {
@@ skipping 15 matching lines @@
   }
   bool haveScriptBlockingStylesheetsLoaded() const {
     return !hasPendingScriptBlockingSheets() || m_ignorePendingStylesheets;
   }
   bool haveRenderBlockingStylesheetsLoaded() const {
     return !hasPendingRenderBlockingSheets() || m_ignorePendingStylesheets;
   }
   bool ignoringPendingStylesheets() const { return m_ignorePendingStylesheets; }
 
   unsigned maxDirectAdjacentSelectors() const {
-    return m_maxDirectAdjacentSelectors;
+    return ruleFeatureSet().maxDirectAdjacentSelectors();
   }
-  bool usesSiblingRules() const { return m_usesSiblingRules; }
-  bool usesFirstLineRules() const { return m_usesFirstLineRules; }
+  bool usesSiblingRules() const { return ruleFeatureSet().usesSiblingRules(); }
+  bool usesFirstLineRules() const {
+    return ruleFeatureSet().usesFirstLineRules();
+  }
   bool usesWindowInactiveSelector() const {
-    return m_usesWindowInactiveSelector;
+    return ruleFeatureSet().usesWindowInactiveSelector();
   }
 
   bool usesRemUnits() const { return m_usesRemUnits; }
-  void setUsesRemUnit(bool b) { m_usesRemUnits = b; }
+  void setUsesRemUnit(bool usesRemUnits) { m_usesRemUnits = usesRemUnits; }
 
   void resetCSSFeatureFlags(const RuleFeatureSet&);
 
   void shadowRootRemovedFromDocument(ShadowRoot*);
-  void appendActiveAuthorStyleSheets();
   void addTreeBoundaryCrossingScope(const TreeScope&);
   const DocumentOrderedList& treeBoundaryCrossingScopes() const {
     return m_treeBoundaryCrossingScopes;
   }
   void resetAuthorStyle(TreeScope&);
 
-  StyleResolver* resolver() const { return m_resolver.get(); }
+  StyleResolver* resolver() const { return m_resolver; }
 
   StyleResolver& ensureResolver() {
     if (!m_resolver) {
       createResolver();
     } else if (m_resolver->hasPendingAuthorStyleSheets()) {
       viewportRulesChanged();
       m_resolver->appendPendingAuthorStyleSheets();
+      finishAppendAuthorStyleSheets();
+    } else if (m_globalRuleSet.isDirty()) {
+      m_globalRuleSet.update(document());
     }
-    return *m_resolver.get();
+    return *m_resolver;
   }
 
-  bool hasResolver() const { return m_resolver.get(); }
+  bool hasResolver() const { return m_resolver; }
   void clearResolver();
   void clearMasterResolver();
 
   StyleInvalidator& styleInvalidator() { return m_styleInvalidator; }
 
-  CSSFontSelector* fontSelector() { return m_fontSelector.get(); }
+  CSSFontSelector* fontSelector() { return m_fontSelector; }
   void setFontSelector(CSSFontSelector*);
 
   void removeFontFaceRules(const HeapVector<Member<const StyleRuleFontFace>>&);
   void clearFontCache();
   // updateGenericFontFamilySettings is used from WebSettingsImpl.
   void updateGenericFontFamilySettings();
 
   void didDetach();
   bool shouldClearResolver() const;
   void resolverChanged(StyleResolverUpdateMode);
 
   CSSStyleSheet* createSheet(Element&,
                              const String& text,
                              TextPosition startPosition,
                              StyleEngineContext&);
 
   void collectScopedStyleFeaturesTo(RuleFeatureSet&) const;
-  void ensureFullscreenUAStyle();
+  void ensureUAStyleForFullscreen();
+  void ensureUAStyleForElement(const Element&);
 
   void platformColorsChanged();
 
+  bool hasRulesForId(const AtomicString& id) const;
   void classChangedForElement(const SpaceSplitString& changedClasses, Element&);
   void classChangedForElement(const SpaceSplitString& oldClasses,
                               const SpaceSplitString& newClasses,
                               Element&);
   void attributeChangedForElement(const QualifiedName& attributeName, Element&);
   void idChangedForElement(const AtomicString& oldId,
                            const AtomicString& newId,
                            Element&);
   void pseudoStateChangedForElement(CSSSelector::PseudoType, Element&);
   void scheduleSiblingInvalidationsForElement(Element&,
                                               ContainerNode& schedulingParent,
                                               unsigned minDirectAdjacent);
   void scheduleInvalidationsForInsertedSibling(Element* beforeElement,
                                                Element& insertedElement);
   void scheduleInvalidationsForRemovedSibling(Element* beforeElement,
                                               Element& removedElement,
                                               Element& afterElement);
   void scheduleNthPseudoInvalidations(ContainerNode&);
   void scheduleInvalidationsForRuleSets(TreeScope&,
                                         const HeapVector<Member<RuleSet>>&);
 
   unsigned styleForElementCount() const { return m_styleForElementCount; }
   void incStyleForElementCount() { m_styleForElementCount++; }
 
   StyleResolverStats* stats() { return m_styleResolverStats.get(); }
   void setStatsEnabled(bool);
 
+  PassRefPtr<ComputedStyle> findSharedStyle(const ElementResolveContext&);
+
   DECLARE_VIRTUAL_TRACE();
   DECLARE_TRACE_WRAPPERS();
 
  private:
   // CSSFontSelectorClient implementation.
   void fontsNeedUpdate(CSSFontSelector*) override;
 
  private:
   StyleEngine(Document&);
 
   TreeScopeStyleSheetCollection* ensureStyleSheetCollectionFor(TreeScope&);
   TreeScopeStyleSheetCollection* styleSheetCollectionFor(TreeScope&);
   bool shouldUpdateDocumentStyleSheetCollection(StyleResolverUpdateMode) const;
   bool shouldUpdateShadowTreeStyleSheetCollection(
       StyleResolverUpdateMode) const;
 
   void markDocumentDirty();
   void markTreeScopeDirty(TreeScope&);
 
   bool isMaster() const { return m_isMaster; }
   Document* master();
   Document& document() const { return *m_document; }
 
   typedef HeapHashSet<Member<TreeScope>> UnorderedTreeScopeSet;
 
   void clearMediaQueryRuleSetOnTreeScopeStyleSheets(UnorderedTreeScopeSet&);
+  const RuleFeatureSet& ruleFeatureSet() const {
+    return m_globalRuleSet.ruleFeatureSet();
+  }
 
   void createResolver();
+  void appendActiveAuthorStyleSheets();
+  void finishAppendAuthorStyleSheets();
 
   CSSStyleSheet* parseSheet(Element&,
                             const String& text,
                             TextPosition startPosition);
 
   const DocumentStyleSheetCollection& documentStyleSheetCollection() const {
     DCHECK(m_documentStyleSheetCollection);
     return *m_documentStyleSheetCollection;
   }
 
@@ skipping 34 matching lines @@
   StyleSheetCollectionMap m_styleSheetCollectionMap;
 
   bool m_documentScopeDirty = true;
   UnorderedTreeScopeSet m_dirtyTreeScopes;
   UnorderedTreeScopeSet m_activeTreeScopes;
   DocumentOrderedList m_treeBoundaryCrossingScopes;
 
   String m_preferredStylesheetSetName;
   String m_selectedStylesheetSetName;
 
-  bool m_usesSiblingRules = false;
-  bool m_usesFirstLineRules = false;
-  bool m_usesWindowInactiveSelector = false;
+  CSSGlobalRuleSet m_globalRuleSet;
+
   bool m_usesRemUnits = false;
-  unsigned m_maxDirectAdjacentSelectors = 0;
-
   bool m_ignorePendingStylesheets = false;
   bool m_didCalculateResolver = false;
 
   Member<StyleResolver> m_resolver;
   Member<ViewportStyleResolver> m_viewportResolver;
   StyleInvalidator m_styleInvalidator;
 
   Member<CSSFontSelector> m_fontSelector;
 
   HeapHashMap<AtomicString, WeakMember<StyleSheetContents>> m_textToSheetCache;
   HeapHashMap<WeakMember<StyleSheetContents>, AtomicString> m_sheetToTextCache;
 
   std::unique_ptr<StyleResolverStats> m_styleResolverStats;
   unsigned m_styleForElementCount = 0;
 
   friend class StyleEngineTest;
 };
 
 }  // namespace blink
 
 #endif