Current work-in-progress crbug.com/567021

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)
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
@@ skipping 12 matching lines @@
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef StyleEngine_h
 #define StyleEngine_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/ListHashSet.h"
 #include "wtf/TemporaryChange.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class CSSFontSelector;
 class CSSStyleSheet;
+class MediaQueryEvaluator;
 class Node;
 class RuleFeatureSet;
 class ShadowTreeStyleSheetCollection;
 class StyleRuleFontFace;
 class StyleSheet;
 class StyleSheetContents;
+class ViewportStyleResolver;
 
 class CORE_EXPORT StyleEngine final : public GarbageCollectedFinalized<StyleEngine>, public CSSFontSelectorClient  {
     USING_GARBAGE_COLLECTED_MIXIN(StyleEngine);
 public:
 
     class IgnoringPendingStylesheet : public TemporaryChange<bool> {
         DISALLOW_NEW();
     public:
         IgnoringPendingStylesheet(StyleEngine& engine)
             : TemporaryChange<bool>(engine.m_ignorePendingStylesheets, true)
         {
         }
     };
 
     friend class IgnoringPendingStylesheet;
 
     static StyleEngine* create(Document& document) { return new StyleEngine(document); }
 
     ~StyleEngine();
 
     const HeapVector<Member<StyleSheet>>& styleSheetsForStyleSheetList(TreeScope&);
+    const HeapVector<Member<CSSStyleSheet>>& injectedAuthorStyleSheets() const { return m_injectedAuthorStyleSheets; }
+    const ActiveStyleSheetVector activeStyleSheetsForInspector();
 
-    const HeapVector<Member<CSSStyleSheet>>& injectedAuthorStyleSheets() const { return m_injectedAuthorStyleSheets; }
+    void setNeedsActiveStyleUpdate(TreeScope&);
+    void setNeedsGlobalRuleSetUpdate() { m_needsGlobalRuleSetUpdate = true; }
+    bool needsActiveStyleUpdate() const { return needsActiveStyleSheetUpdate() || m_needsGlobalRuleSetUpdate; }
+    void updateActiveStyle();
 
-    const HeapVector<Member<CSSStyleSheet>> activeStyleSheetsForInspector() const;
-
-    void setNeedsActiveStyleUpdate(StyleSheet*, StyleResolverUpdateMode);
     void addStyleSheetCandidateNode(Node*);
     void removeStyleSheetCandidateNode(Node*);
     void removeStyleSheetCandidateNode(Node*, TreeScope&);
     void modifiedStyleSheetCandidateNode(Node*);
+
     void watchedSelectorsChanged();
-
     void injectAuthorSheet(StyleSheetContents* authorSheet);
 
-    void clearMediaQueryRuleSetStyleSheets();
+    void mediaQueryAffectingValueChanged();
     void updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector);
-    void updateActiveStyleSheets(StyleResolverUpdateMode);
 
     String preferredStylesheetSetName() const { return m_preferredStylesheetSetName; }
     String selectedStylesheetSetName() const { return m_selectedStylesheetSetName; }
     void setPreferredStylesheetSetNameIfNotSet(const String&);
     void setSelectedStylesheetSetName(const String&);
     void setHttpDefaultStyle(const String&);
 
     void addPendingSheet(StyleEngineContext&);
     void removePendingSheet(Node* styleSheetCandidateNode, const StyleEngineContext&);
 
-    bool hasPendingScriptBlockingSheets() const { return m_pendingScriptBlockingStylesheets > 0; }
-    bool hasPendingRenderBlockingSheets() const { return m_pendingRenderBlockingStylesheets > 0; }
+    bool hasPendingScriptBlockingSheets() const { return m_pendingScriptBlockingStylesheets; }
+    bool hasPendingRenderBlockingSheets() const { return m_pendingRenderBlockingStylesheets; }
     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; }
-    bool usesSiblingRules() const { return m_usesSiblingRules; }
-    bool usesFirstLineRules() const { return m_usesFirstLineRules; }
-    bool usesWindowInactiveSelector() const { return m_usesWindowInactiveSelector; }
-
     bool usesRemUnits() const { return m_usesRemUnits; }
     void setUsesRemUnit(bool b) { m_usesRemUnits = b; }
 
-    void resetCSSFeatureFlags(const RuleFeatureSet&);
+    unsigned maxDirectAdjacentSelectors() const { return m_globalRuleSet.m_features.maxDirectAdjacentSelectors(); }
+    bool usesSiblingRules() const { return m_globalRuleSet.m_features.usesSiblingRules(); }
+    bool usesFirstLineRules() const { return m_globalRuleSet.m_features.usesFirstLineRules(); }
+    bool usesWindowInactiveSelector() const { return m_globalRuleSet.m_features.usesWindowInactiveSelector(); }
+    RuleSet* watchedSelectorsRuleSet() { return m_globalRuleSet.m_watchedSelectorsRuleSet; }
 
     void didRemoveShadowRoot(ShadowRoot*);
     void shadowRootRemovedFromDocument(ShadowRoot*);
-    void appendActiveAuthorStyleSheets();
+    void markAllTreeScopesDirty() { m_allTreeScopesDirty = true; }
+    void addTreeBoundaryCrossingScope(ContainerNode& scope);
+
+    void collectScopedStyleFeaturesTo(RuleFeatureSet&) const;
+
+    RuleSet& ensureRuleSetForSheet(CSSStyleSheet&);
 
     StyleResolver* resolver() const
     {
         return m_resolver.get();
     }
 
     StyleResolver& ensureResolver()
     {
-        if (!m_resolver) {
+        updateActiveStyle();
+        if (!m_resolver)
             createResolver();
-        } else if (m_resolver->hasPendingAuthorStyleSheets()) {
-            m_resolver->appendPendingAuthorStyleSheets();
-        }
         return *m_resolver.get();
     }
 
     bool hasResolver() const { return m_resolver.get(); }
     void clearResolver();
-    void clearMasterResolver();
 
     StyleInvalidator& styleInvalidator() { return m_styleInvalidator; }
+    MediaQueryEvaluator& ensureMediaQueryEvaluator();
+    bool mediaQueryAffectedByViewportChange();
+    bool mediaQueryAffectedByDeviceChange();
+    bool hasViewportDependentMediaQueries() const { return !m_globalRuleSet.m_features.viewportDependentMediaQueryResults.isEmpty(); }
 
     CSSFontSelector* fontSelector() { return m_fontSelector.get(); }
     void setFontSelector(CSSFontSelector*);
 
     void removeFontFaceRules(const HeapVector<Member<const StyleRuleFontFace>>&);
+    void removeFontFaceRules(const HeapVector<Member<StyleRuleFontFace>>&);
     void clearFontCache();
     // updateGenericFontFamilySettings is used from WebSettingsImpl.
     void updateGenericFontFamilySettings();
 
+    ViewportStyleResolver& ensureViewportStyleResolver();
+
     void didDetach();
     bool shouldClearResolver() const;
-    void resolverChanged(StyleResolverUpdateMode);
 
     CSSStyleSheet* createSheet(Element*, const String& text, TextPosition startPosition, StyleEngineContext&);
     void removeSheet(StyleSheetContents*);
 
-    void collectScopedStyleFeaturesTo(RuleFeatureSet&) const;
-    void ensureFullscreenUAStyle();
-
     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 scheduleInvalidationsForRuleSets(TreeScope&, const HeapVector<Member<RuleSet>>&);
+
+    void ensureUAStyleForFullscreen();
+    void ensureUAStyleForElement(const Element&);
+
+    PassRefPtr<ComputedStyle> findSharedStyle(const ElementResolveContext&);
+
+    const DocumentOrderedList& treeBoundaryCrossingScopes() const { return m_treeBoundaryCrossingScopes; }
 
     unsigned styleForElementCount() const { return m_styleForElementCount; }
     void incStyleForElementCount() { m_styleForElementCount++; }
 
     StyleResolverStats* stats() { return m_styleResolverStats.get(); }
     void setStatsEnabled(bool);
 
     DECLARE_VIRTUAL_TRACE();
 
     DECLARE_TRACE_WRAPPERS();
 
 private:
     // CSSFontSelectorClient implementation.
     void fontsNeedUpdate(CSSFontSelector*) override;
 
 private:
     StyleEngine(Document&);
 
+    void updateViewport();
+    void updateActiveStyleSheets();
+    void updateGlobalRuleSet();
+
+    bool needsActiveStyleSheetUpdate() const { return m_allTreeScopesDirty || m_documentScopeDirty || m_dirtyTreeScopes.size(); }
+
     TreeScopeStyleSheetCollection* ensureStyleSheetCollectionFor(TreeScope&);
     TreeScopeStyleSheetCollection* styleSheetCollectionFor(TreeScope&);
-    bool shouldUpdateDocumentStyleSheetCollection(StyleResolverUpdateMode) const;
-    bool shouldUpdateShadowTreeStyleSheetCollection(StyleResolverUpdateMode) const;
+    bool shouldUpdateDocumentStyleSheetCollection() const;
+    bool shouldUpdateShadowTreeStyleSheetCollection() 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&);
+    void mediaQueryAffectingValueChanged(UnorderedTreeScopeSet&);
+    const RuleFeatureSet& ruleFeatureSet() const { return m_globalRuleSet.m_features; }
 
     void createResolver();
 
-    static CSSStyleSheet* parseSheet(Element*, const String& text, TextPosition startPosition);
+    CSSStyleSheet* parseSheet(Element*, const String& text, TextPosition startPosition);
 
     const DocumentStyleSheetCollection* documentStyleSheetCollection() const
     {
         return m_documentStyleSheetCollection.get();
     }
 
     DocumentStyleSheetCollection* documentStyleSheetCollection()
     {
         return m_documentStyleSheetCollection.get();
     }
 
-    void updateActiveStyleSheetsInShadow(StyleResolverUpdateMode, TreeScope*, UnorderedTreeScopeSet& treeScopesRemoved);
+    void updateActiveStyleSheetsInShadow(TreeScope*, UnorderedTreeScopeSet& treeScopesRemoved);
 
     bool shouldSkipInvalidationFor(const Element&) const;
+    void scheduleRuleSetInvalidationsForElement(Element&, const HeapVector<Member<RuleSet>>&);
 
     Member<Document> m_document;
     bool m_isMaster;
 
     // Track the number of currently loading top-level stylesheets needed for layout.
     // Sheets loaded using the @import directive are not included in this count.
     // We use this count of pending sheets to detect when we can begin attaching
     // elements and when it is safe to execute scripts.
-    int m_pendingScriptBlockingStylesheets = 0;
-    int m_pendingRenderBlockingStylesheets = 0;
+    unsigned m_pendingScriptBlockingStylesheets = 0;
+    unsigned m_pendingRenderBlockingStylesheets = 0;
 
     HeapVector<Member<CSSStyleSheet>> m_injectedAuthorStyleSheets;
-
     Member<DocumentStyleSheetCollection> m_documentStyleSheetCollection;
 
-    typedef HeapHashMap<WeakMember<TreeScope>, Member<ShadowTreeStyleSheetCollection>> StyleSheetCollectionMap;
+    using StyleSheetCollectionMap = HeapHashMap<WeakMember<TreeScope>, Member<ShadowTreeStyleSheetCollection>>;
+
     StyleSheetCollectionMap m_styleSheetCollectionMap;
 
     bool m_documentScopeDirty = true;
+    bool m_allTreeScopesDirty = false;
     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_needsGlobalRuleSetUpdate = true;
     bool m_usesRemUnits = false;
-    unsigned m_maxDirectAdjacentSelectors = 0;
-
     bool m_ignorePendingStylesheets = false;
     bool m_didCalculateResolver = false;
 
     Member<StyleResolver> m_resolver;
+    Member<ViewportStyleResolver> m_viewportResolver;
+    Member<MediaQueryEvaluator> m_medium;
     StyleInvalidator m_styleInvalidator;
 
     Member<CSSFontSelector> m_fontSelector;
 
     HeapHashMap<AtomicString, Member<StyleSheetContents>> m_textToSheetCache;
     HeapHashMap<Member<StyleSheetContents>, AtomicString> m_sheetToTextCache;
 
     OwnPtr<StyleResolverStats> m_styleResolverStats;
     unsigned m_styleForElementCount = 0;
 
     friend class StyleEngineTest;
 };
 
 } // namespace blink
 
 #endif