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

Source/core/dom/TreeScope.cpp

 /*
  * 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 46 matching lines @@
 using namespace HTMLNames;
 
 TreeScope::TreeScope(ContainerNode& rootNode, Document& document)
     : m_rootNode(&rootNode)
     , m_document(&document)
     , m_parentTreeScope(&document)
 #if !ENABLE(OILPAN)
     , m_guardRefCount(0)
 #endif
     , m_idTargetObserverRegistry(IdTargetObserverRegistry::create())
+    , m_inActiveStyleSheetsTraversal(false)
 {
     ASSERT(rootNode != document);
 #if !ENABLE(OILPAN)
     m_parentTreeScope->guardRef();
 #endif
     m_rootNode->setTreeScope(this);
 }
 
 TreeScope::TreeScope(Document& document)
     : m_rootNode(document)
     , m_document(&document)
     , m_parentTreeScope(nullptr)
 #if !ENABLE(OILPAN)
     , m_guardRefCount(0)
 #endif
     , m_idTargetObserverRegistry(IdTargetObserverRegistry::create())
+    , m_inActiveStyleSheetsTraversal(false)
 {
     m_rootNode->setTreeScope(this);
 }
 
 TreeScope::~TreeScope()
 {
 #if !ENABLE(OILPAN)
     ASSERT(!m_guardRefCount);
     m_rootNode->setTreeScope(0);
 
     if (m_selection) {
         m_selection->clearTreeScope();
         m_selection = nullptr;
     }
 
+    if (m_inActiveStyleSheetsTraversal)
+        removeFromActiveStyleSheetsTraversal();
+
     if (m_parentTreeScope)
         m_parentTreeScope->guardDeref();
 #endif
 }
 
 TreeScope* TreeScope::olderShadowRootOrParentTreeScope() const
 {
     if (rootNode().isShadowRoot()) {
         if (ShadowRoot* olderShadowRoot = toShadowRoot(rootNode()).olderShadowRoot())
             return olderShadowRoot;
@@ skipping 22 matching lines @@
     m_imageMapsByName.clear();
     m_labelsByForAttribute.clear();
 }
 #endif
 
 void TreeScope::setParentTreeScope(TreeScope& newParentScope)
 {
     // A document node cannot be re-parented.
     ASSERT(!rootNode().isDocumentNode());
 
+    if (m_inActiveStyleSheetsTraversal)
+        removeFromActiveStyleSheetsTraversal();
 #if !ENABLE(OILPAN)
     newParentScope.guardRef();
     if (m_parentTreeScope)
         m_parentTreeScope->guardDeref();
 #endif
     m_parentTreeScope = &newParentScope;
     setDocument(newParentScope.document());
 }
 
 ScopedStyleResolver& TreeScope::ensureScopedStyleResolver()
@@ skipping 411 matching lines @@
 {
     for (Element* element = ElementTraversal::firstWithin(rootNode()); element; element = ElementTraversal::nextIncludingPseudo(*element)) {
         for (ShadowRoot* root = element->youngestShadowRoot(); root; root = root->olderShadowRoot())
             root->setNeedsStyleRecalcForViewportUnits();
         const ComputedStyle* style = element->computedStyle();
         if (style && style->hasViewportUnits())
             element->setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::ViewportUnits));
     }
 }
 
+TreeScopeStyleSheetCollection* TreeScope::styleSheetCollection()
+{
+    return document().styleEngine().styleSheetCollectionFor(*this);
+}
+
+bool TreeScope::OrderedTreeScopeSet::insert(TreeScope* treeScope)
+{
+    if (m_treeScopes.isEmpty()) {
+        m_treeScopes.append(treeScope);
+        m_hash.add(treeScope);
+        return true;
+    }
+    if (m_hash.contains(treeScope))
+        return false;
+
+    int end = m_treeScopes.size() - 1;
+    int start = 0;
+    int position = 0;
+    unsigned result = 0;
+
+    while (start <= end) {
+        position = (start + end) / 2;
+        result = m_treeScopes[position]->comparePosition(*treeScope);
+
+        if (result & Node::DOCUMENT_POSITION_PRECEDING) {
+            end = position - 1;
+        } else {
+            ASSERT(result & Node::DOCUMENT_POSITION_FOLLOWING);
+            start = position + 1;
+        }
+    }
+
+    if (result & Node::DOCUMENT_POSITION_FOLLOWING) {
+        ++position;
+        ASSERT(static_cast<size_t>(position) == m_treeScopes.size() || (m_treeScopes[position]->comparePosition(*treeScope) & Node::DOCUMENT_POSITION_PRECEDING));
+    }
+    m_treeScopes.insert(position, treeScope);
+    m_hash.add(treeScope);
+
+#if ENABLE(ASSERT)
+    // Check whether m_treeScopes is sorted in document order or not.
+    for (unsigned i = 0; i < m_treeScopes.size() - 1; ++i) {
+        unsigned result = m_treeScopes[i]->comparePosition(*m_treeScopes[i + 1]);
+        ASSERT(result & Node::DOCUMENT_POSITION_FOLLOWING);
+    }
+#endif
+    return true;
+}
+
+bool TreeScope::OrderedTreeScopeSet::remove(TreeScope* treeScope)
+{
+    if (!m_hash.contains(treeScope))
+        return false;
+    size_t position = m_treeScopes.find(treeScope);
+    m_treeScopes.remove(position);
+    m_hash.remove(treeScope);
+    return true;
+}
+
+DEFINE_TRACE(TreeScope::OrderedTreeScopeSet)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_treeScopes);
+    visitor->trace(m_hash);
+#endif
+}
+
+TreeScope::TreeScopesWithActiveStyleSheetsTraversal::TreeScopesWithActiveStyleSheetsTraversal(TreeScope& treeScope)
+    : m_current(&treeScope), m_iterator(nullptr), m_end(nullptr)
+{
+    skipIfNoStyleSheetCollection();
+}
+
+TreeScope::TreeScopesWithActiveStyleSheetsTraversal::TreeScopesWithActiveStyleSheetsTraversal(OrderedTreeScopeSet& treeScopes)
+    : m_current(nullptr), m_iterator(treeScopes.begin()), m_end(treeScopes.end())
+{
+    if (m_iterator != m_end)
+        m_current = *m_iterator;
+    skipIfNoStyleSheetCollection();
+}
+
+void TreeScope::TreeScopesWithActiveStyleSheetsTraversal::skipIfNoStyleSheetCollection()
+{
+    while (m_current && !m_current->styleSheetCollection())
+        next();
+}
+
+void TreeScope::TreeScopesWithActiveStyleSheetsTraversal::nextWithStyleSheetCollection()
+{
+    do {
+        next();
+    } while (m_current && !m_current->styleSheetCollection());
+}
+
+void TreeScope::TreeScopesWithActiveStyleSheetsTraversal::next()
+{
+    if (!m_current)
+        return;
+
+    OrderedTreeScopeSet& children = m_current->m_childTreeScopesWithActiveStyleSheets;
+    if (!children.isEmpty()) {
+        if (m_iterator) {
+            ++m_iterator;
+            if (m_iterator != m_end)
+                m_stack.append(std::make_pair(m_iterator, m_end));
+        }
+        m_iterator = children.begin();
+        m_end = children.end();
+        ASSERT(m_iterator != m_end);
+        m_current = *m_iterator;
+        return;
+    }
+
+    if (!m_iterator) {
+        m_current = nullptr;
+        return;
+    }
+
+    ++m_iterator;
+    if (m_iterator != m_end) {
+        m_current = *m_iterator;
+        return;
+    }
+
+    if (m_stack.isEmpty()) {
+        m_current = nullptr;
+        return;
+    }
+
+    m_iterator = m_stack.last().first;
+    m_end = m_stack.last().second;
+    ASSERT(m_iterator != m_end);
+    m_stack.removeLast();
+    m_current = *m_iterator;
+}
+
+DEFINE_TRACE(TreeScope::TreeScopesWithActiveStyleSheetsTraversal)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_current);
+    visitor->trace(m_iterator);
+    visitor->trace(m_end);
+    visitor->trace(m_stack);
+#endif
+}
+
+void TreeScope::insertToActiveStyleSheetsTraversal()

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

nit: insertToActiveStyleSheetsTraversal() sounds a bit strange,
as *Traversal means traversing a tree-like structure.

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

Changed to setSelfOrDescendantsHaveActiveStyleSheets(). Does this sound better?

+{
+    ASSERT(this != m_document);
+    for (TreeScope* treeScope = this;;) {
+        TreeScope* parent = treeScope->parentTreeScope();
+        if (!parent)
+            break;
+        parent->m_childTreeScopesWithActiveStyleSheets.insert(treeScope);
+        treeScope->m_inActiveStyleSheetsTraversal = true;

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

nit: maybe m_hasActiveStyleSheets?  This also sounds a bit weird to call this
"in...Traversal" to me.

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

Changed to m_selfOrDescendantsHaveActiveStyleSheets. This flag is set when
descendants have active stylesheets, even if |this| does not.

+
+        // Make sure to include parents so that we can traverse to this from the root treeScope.
+        treeScope = parent;
+        if (treeScope->m_inActiveStyleSheetsTraversal)
+            break;
+    }
+}
+
+void TreeScope::removeFromActiveStyleSheetsTraversal()

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

nit: ditto as insertToActiveStyleSheetsTraversal()

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

Done.

+{
+    ASSERT(this != m_document);
+    ASSERT(parentTreeScope());
+    ASSERT(m_inActiveStyleSheetsTraversal);
+    for (TreeScope* treeScope = this;;) {
+        TreeScope* parent = treeScope->parentTreeScope();
+        if (!parent)
+            break;
+        parent->m_childTreeScopesWithActiveStyleSheets.remove(treeScope);
+        treeScope->m_inActiveStyleSheetsTraversal = false;
+
+        // Remove parents if they were included only to traverse to this.
+        treeScope = parent;
+        if (!treeScope->m_inActiveStyleSheetsTraversal || !treeScope->m_childTreeScopesWithActiveStyleSheets.isEmpty())
+            break;
+    }
+}
+
 DEFINE_TRACE(TreeScope)
 {
     visitor->trace(m_rootNode);
     visitor->trace(m_document);
     visitor->trace(m_parentTreeScope);
     visitor->trace(m_idTargetObserverRegistry);
     visitor->trace(m_selection);
     visitor->trace(m_elementsById);
     visitor->trace(m_imageMapsByName);
     visitor->trace(m_labelsByForAttribute);
     visitor->trace(m_scopedStyleResolver);
+    visitor->trace(m_childTreeScopesWithActiveStyleSheets);
 }
 
 } // namespace blink