WIP: Move StyleEngine::m_activeTreeScopes to TreeScope::m_childTreeScopesWithActiveStyleSheets

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 63 matching lines @@
 
 #if !ENABLE(OILPAN)
     void detachFromDocument();
 #endif
 
     const WillBeHeapVector<RefPtrWillBeMember<StyleSheet>>& styleSheetsForStyleSheetList(TreeScope&);
     const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>>& activeAuthorStyleSheets() const;
 
     const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>>& documentAuthorStyleSheets() const { return m_authorStyleSheets; }
 
-    const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>> activeStyleSheetsForInspector() const;
+    const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>> activeStyleSheetsForInspector();
 
     void modifiedStyleSheet(StyleSheet*);
     void addStyleSheetCandidateNode(Node*, bool createdByParser);
     void removeStyleSheetCandidateNode(Node*);
     void removeStyleSheetCandidateNode(Node*, TreeScope&);
     void modifiedStyleSheetCandidateNode(Node*);
 
     void addAuthorSheet(PassRefPtrWillBeRawPtr<StyleSheetContents> authorSheet);
 
     void clearMediaQueryRuleSetStyleSheets();
@@ skipping 75 matching lines @@
     void collectScopedStyleFeaturesTo(RuleFeatureSet&) const;
 
     void platformColorsChanged();
 
     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&);
 
+    TreeScopeStyleSheetCollection* styleSheetCollectionFor(TreeScope&);
+
     DECLARE_VIRTUAL_TRACE();
 
 private:
     // CSSFontSelectorClient implementation.
     virtual void fontsNeedUpdate(CSSFontSelector*) override;
 
 private:
     StyleEngine(Document&);
 
     TreeScopeStyleSheetCollection* ensureStyleSheetCollectionFor(TreeScope&);
-    TreeScopeStyleSheetCollection* styleSheetCollectionFor(TreeScope&);
     bool shouldUpdateDocumentStyleSheetCollection(StyleResolverUpdateMode) const;
     bool shouldUpdateShadowTreeStyleSheetCollection(StyleResolverUpdateMode) const;
 
     void markTreeScopeDirty(TreeScope&);
 
     bool isMaster() const { return m_isMaster; }
     Document* master();
     Document& document() const { return *m_document; }
 
     void scheduleInvalidationSetsForElement(const InvalidationSetVector&, Element&);
 
-    typedef WillBeHeapHashSet<RawPtrWillBeMember<TreeScope>> UnorderedTreeScopeSet;
-
-    // A class which holds document-ordered treescopes which have stylesheets.
-    // ListHashSet allows only sequential access, not random access.
-    // So it gets slow when the size of treescopes gets larger when finding
-    // the best place to insert a treescope into the document-ordered
-    // treescopes (requires linear search).
-    // To solve this, use a vector for the document-ordered treescopes and
-    // use a hashset for quickly checking whether a given treescope is
-    // in the document-ordered treescopes or not.
-    class OrderedTreeScopeSet final {
-        DISALLOW_ALLOCATION();
-        WTF_MAKE_NONCOPYABLE(OrderedTreeScopeSet);
-    public:
-        OrderedTreeScopeSet() { }
-
-        void insert(TreeScope*);
-        void remove(TreeScope*);
-
-        // When we don't need to consider document-order, use this iterator.
-        // Otherwise, use [] operator.
-        UnorderedTreeScopeSet::iterator beginUnordered() { return m_hash.begin(); }
-        UnorderedTreeScopeSet::iterator endUnordered() { return m_hash.end(); }
-
-        bool isEmpty() const { return m_treeScopes.isEmpty(); }
-        void clear()
-        {
-            m_treeScopes.clear();
-            m_hash.clear();
-        }
-
-        size_t size() const { return m_treeScopes.size(); }
-
-        TreeScope* operator[](size_t i) { return m_treeScopes[i]; }
-        const TreeScope* operator[](size_t i) const { return m_treeScopes[i]; }
-
-        DECLARE_TRACE();
-
-    private:
-        WillBeHeapVector<RawPtrWillBeMember<TreeScope>, 16> m_treeScopes;
-        UnorderedTreeScopeSet m_hash;
-    };
-
-    static void insertTreeScopeInDocumentOrder(OrderedTreeScopeSet&, TreeScope*);
-    void clearMediaQueryRuleSetOnTreeScopeStyleSheets(UnorderedTreeScopeSet::iterator begin, UnorderedTreeScopeSet::iterator end);
-
     void createResolver();
 
     static PassRefPtrWillBeRawPtr<CSSStyleSheet> parseSheet(Element*, const String& text, TextPosition startPosition, bool createdByParser);
 
     const DocumentStyleSheetCollection* documentStyleSheetCollection() const
     {
         return m_documentStyleSheetCollection.get();
     }
 
     DocumentStyleSheetCollection* documentStyleSheetCollection()
     {
         return m_documentStyleSheetCollection.get();
     }
 
-    void updateActiveStyleSheetsInShadow(StyleResolverUpdateMode, TreeScope*, UnorderedTreeScopeSet& treeScopesRemoved);
+    void updateActiveStyleSheetsInShadow(StyleResolverUpdateMode, TreeScope*, TreeScope::UnorderedTreeScopeSet& treeScopesRemoved);
 
     RawPtrWillBeMember<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_pendingStylesheets;
 
     WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>> m_authorStyleSheets;
 
     OwnPtrWillBeMember<DocumentStyleSheetCollection> m_documentStyleSheetCollection;
 
     typedef WillBeHeapHashMap<RawPtrWillBeWeakMember<TreeScope>, OwnPtrWillBeMember<ShadowTreeStyleSheetCollection>> StyleSheetCollectionMap;
     StyleSheetCollectionMap m_styleSheetCollectionMap;
 
     bool m_documentScopeDirty;
-    UnorderedTreeScopeSet m_dirtyTreeScopes;
-    OrderedTreeScopeSet m_activeTreeScopes;
+    TreeScope::UnorderedTreeScopeSet m_dirtyTreeScopes;
 
     String m_preferredStylesheetSetName;
     String m_selectedStylesheetSetName;
 
     bool m_usesSiblingRules;
     bool m_usesFirstLineRules;
     bool m_usesWindowInactiveSelector;
     bool m_usesRemUnits;
     unsigned m_maxDirectAdjacentSelectors;
 
     bool m_ignorePendingStylesheets;
     bool m_didCalculateResolver;
     OwnPtrWillBeMember<StyleResolver> m_resolver;
     StyleInvalidator m_styleInvalidator;
 
     RefPtrWillBeMember<CSSFontSelector> m_fontSelector;
 
     WillBeHeapHashMap<AtomicString, RawPtrWillBeMember<StyleSheetContents>> m_textToSheetCache;
     WillBeHeapHashMap<RawPtrWillBeMember<StyleSheetContents>, AtomicString> m_sheetToTextCache;
 };
 
 }
 
 #endif