Stop sorting StyleEngine::m_activeTreeScopes

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 183 matching lines @@
     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 clearMediaQueryRuleSetOnTreeScopeStyleSheets(UnorderedTreeScopeSet&);
 
     void createResolver();
 
     static PassRefPtrWillBeRawPtr<CSSStyleSheet> parseSheet(Element*, const String& text, TextPosition startPosition, bool createdByParser);
 
     const DocumentStyleSheetCollection* documentStyleSheetCollection() const
     {
         return m_documentStyleSheetCollection.get();
     }
 
@@ skipping 15 matching lines @@
 
     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;
+    UnorderedTreeScopeSet m_activeTreeScopes;
 
     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