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

Source/core/dom/TreeScope.h

 /*
  * Copyright (C) 2011 Google Inc. All Rights Reserved.
  * Copyright (C) 2012 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 25 matching lines @@
 
 class ContainerNode;
 class DOMSelection;
 class Document;
 class Element;
 class HTMLLabelElement;
 class HTMLMapElement;
 class HitTestResult;
 class HitTestRequest;
 class IdTargetObserverRegistry;
+class Node;
 class ScopedStyleResolver;
-class Node;
+class TreeScopeStyleSheetCollection;
 
 // A class which inherits both Node and TreeScope must call clearRareData() in its destructor
 // so that the Node destructor no longer does problematic NodeList cache manipulation in
 // the destructor.
 class CORE_EXPORT TreeScope : public WillBeGarbageCollectedMixin {
 public:
     TreeScope* parentTreeScope() const { return m_parentTreeScope; }
 
     TreeScope* olderShadowRootOrParentTreeScope() const;
     bool isInclusiveOlderSiblingShadowRootOrAncestorTreeScopeOf(const TreeScope&) const;
@@ skipping 76 matching lines @@
     TreeScope* commonAncestorTreeScope(TreeScope& other);
 
     Element* getElementByAccessKey(const String& key) const;
 
     DECLARE_VIRTUAL_TRACE();
 
     ScopedStyleResolver* scopedStyleResolver() const { return m_scopedStyleResolver.get(); }
     ScopedStyleResolver& ensureScopedStyleResolver();
     void clearScopedStyleResolver();
 
+    TreeScopeStyleSheetCollection* styleSheetCollection();
+
+    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() { }
+
+        bool insert(TreeScope*);
+        bool remove(TreeScope*);
+
+        // When we don't need to consider document-order, use this iterator.
+        // Otherwise, use [] operator.
+        UnorderedTreeScopeSet& unordered() { return m_hash; }
+
+        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]; }
+
+        typedef WillBeHeapVector<RawPtrWillBeMember<TreeScope>, 16>::iterator iterator;
+        iterator begin() { return m_treeScopes.begin(); }
+        iterator end() { return m_treeScopes.end(); }
+
+        DECLARE_TRACE();
+
+    private:
+        WillBeHeapVector<RawPtrWillBeMember<TreeScope>, 16> m_treeScopes;
+        UnorderedTreeScopeSet m_hash;
+    };
+
+    class TreeScopesWithActiveStyleSheetsTraversal final {
+        DISALLOW_ALLOCATION();
+        WTF_MAKE_NONCOPYABLE(TreeScopesWithActiveStyleSheetsTraversal);
+    public:
+        TreeScopesWithActiveStyleSheetsTraversal(TreeScope&);
+        TreeScopesWithActiveStyleSheetsTraversal(OrderedTreeScopeSet&);
+
+        class iterator {
+        public:
+            iterator(TreeScopesWithActiveStyleSheetsTraversal& traversal) : m_traversal(traversal) { }
+            iterator(const iterator& iterator) : m_traversal(iterator.m_traversal) { }
+
+            TreeScope* operator*() { return m_traversal.m_current; }
+            void operator++() { m_traversal.nextWithStyleSheetCollection(); }
+            bool operator!=(const iterator& other) const { return m_traversal.m_current; }
+
+        private:
+            TreeScopesWithActiveStyleSheetsTraversal& m_traversal;
+        };
+
+        iterator begin() { return iterator(*this); }
+        iterator end() { return iterator(*this); }

[kochi, 2015/05/26 01:52:34]

Why begin() and end() are same?

[kojii, 2015/05/26 05:21:58]

end() is not really used, as operator!=() can determine by itself, but I agree
that this is confusing. Fixed.

+
+        DECLARE_TRACE();
+
+    private:
+        void skipIfNoStyleSheetCollection();
+        void nextWithStyleSheetCollection();
+        void next();
+
+        RawPtrWillBeMember<TreeScope> m_current;
+        OrderedTreeScopeSet::iterator m_iterator;
+        OrderedTreeScopeSet::iterator m_end;
+        WillBeHeapVector<std::pair<OrderedTreeScopeSet::iterator, OrderedTreeScopeSet::iterator>, 8> m_stack;
+    };
+
+    bool isInActiveStyleSheetsTraversal() const { return m_inActiveStyleSheetsTraversal; }
+    OrderedTreeScopeSet& childTreeScopesWithActiveStyleSheets() { return m_childTreeScopesWithActiveStyleSheets; }
+    bool hasChildTreeScopesWithActiveStyleSheets() const { return !m_childTreeScopesWithActiveStyleSheets.isEmpty(); }
+    void insertToActiveStyleSheetsTraversal();
+    void removeFromActiveStyleSheetsTraversal();
+
 protected:
     TreeScope(ContainerNode&, Document&);
     TreeScope(Document&);
     virtual ~TreeScope();
 
 #if !ENABLE(OILPAN)
     void destroyTreeScopeData();
 #endif
 
     void setDocument(Document& document) { m_document = &document; }
@@ skipping 30 matching lines @@
     int m_guardRefCount;
 #endif
 
     OwnPtrWillBeMember<DocumentOrderedMap> m_elementsById;
     OwnPtrWillBeMember<DocumentOrderedMap> m_imageMapsByName;
     OwnPtrWillBeMember<DocumentOrderedMap> m_labelsByForAttribute;
 
     OwnPtrWillBeMember<IdTargetObserverRegistry> m_idTargetObserverRegistry;
 
     OwnPtrWillBeMember<ScopedStyleResolver> m_scopedStyleResolver;
+    OrderedTreeScopeSet m_childTreeScopesWithActiveStyleSheets;
 
     mutable RefPtrWillBeMember<DOMSelection> m_selection;
+
+    bool m_inActiveStyleSheetsTraversal : 1;

[kochi, 2015/05/26 01:52:34]

Not necessary to be a bitfield for one boolean.

[kojii, 2015/05/26 05:21:58]

Done.

 };
 
 inline bool TreeScope::hasElementWithId(const AtomicString& id) const
 {
     ASSERT(!id.isNull());
     return m_elementsById && m_elementsById->contains(id);
 }
 
 inline bool TreeScope::containsMultipleElementsWithId(const AtomicString& id) const
 {
     return m_elementsById && m_elementsById->containsMultiple(id);
 }
 
 DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES(TreeScope)
 
 HitTestResult hitTestInDocument(const Document*, int x, int y);
 
 } // namespace blink
 
 #endif // TreeScope_h