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

Source/core/dom/StyleEngine.cpp

 /*
  * 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, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 81 matching lines @@
 
     if (m_fontSelector) {
         m_fontSelector->clearDocument();
         m_fontSelector->unregisterForInvalidationCallbacks(this);
     }
 
     // Decrement reference counts for things we could be keeping alive.
     m_fontSelector.clear();
     m_resolver.clear();
     m_styleSheetCollectionMap.clear();
-    m_activeTreeScopes.clear();
 }
 #endif
 
 inline Document* StyleEngine::master()
 {
     if (isMaster())
         return m_document;
     HTMLImportsController* import = document().importsController();
     if (!import) // Document::import() can return null while executing its destructor.
         return 0;
     return import->master();
 }
 
-void StyleEngine::OrderedTreeScopeSet::insert(TreeScope* treeScope)
-{
-    if (m_treeScopes.isEmpty()) {
-        m_treeScopes.append(treeScope);
-        m_hash.add(treeScope);
-        return;
-    }
-    if (m_hash.contains(treeScope))
-        return;
-
-    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
-}
-
-void StyleEngine::OrderedTreeScopeSet::remove(TreeScope* treeScope)
-{
-    if (!m_hash.contains(treeScope))
-        return;
-    size_t position = m_treeScopes.find(treeScope);
-    m_treeScopes.remove(position);
-    m_hash.remove(treeScope);
-}
-
-DEFINE_TRACE(StyleEngine::OrderedTreeScopeSet)
-{
-#if ENABLE(OILPAN)
-    visitor->trace(m_treeScopes);
-    visitor->trace(m_hash);
-#endif
-}
-
 TreeScopeStyleSheetCollection* StyleEngine::ensureStyleSheetCollectionFor(TreeScope& treeScope)
 {
     if (treeScope == m_document)
         return documentStyleSheetCollection();
 
     StyleSheetCollectionMap::AddResult result = m_styleSheetCollectionMap.add(&treeScope, nullptr);
     if (result.isNewEntry)
         result.storedValue->value = adoptPtrWillBeNoop(new ShadowTreeStyleSheetCollection(toShadowRoot(treeScope)));
     return result.storedValue->value.get();
 }
@@ skipping 93 matching lines @@
 
     TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
     ASSERT(isStyleElement(*node) || treeScope == m_document);
     ASSERT(!isXSLStyleSheet(*node));
     TreeScopeStyleSheetCollection* collection = ensureStyleSheetCollectionFor(treeScope);
     ASSERT(collection);
     collection->addStyleSheetCandidateNode(node, createdByParser);
 
     markTreeScopeDirty(treeScope);
     if (treeScope != m_document)
-        m_activeTreeScopes.insert(&treeScope);
+        treeScope.setSelfOrDescendantsHaveActiveStyleSheets();
 }
 
 void StyleEngine::removeStyleSheetCandidateNode(Node* node)
 {
     removeStyleSheetCandidateNode(node, *m_document);
 }
 
 void StyleEngine::removeStyleSheetCandidateNode(Node* node, TreeScope& treeScope)
 {
     ASSERT(isStyleElement(*node) || treeScope == m_document);
@@ skipping 22 matching lines @@
 bool StyleEngine::shouldUpdateDocumentStyleSheetCollection(StyleResolverUpdateMode updateMode) const
 {
     return m_documentScopeDirty || updateMode == FullStyleUpdate;
 }
 
 bool StyleEngine::shouldUpdateShadowTreeStyleSheetCollection(StyleResolverUpdateMode updateMode) const
 {
     return !m_dirtyTreeScopes.isEmpty() || updateMode == FullStyleUpdate;
 }
 
-void StyleEngine::clearMediaQueryRuleSetOnTreeScopeStyleSheets(UnorderedTreeScopeSet::iterator begin, UnorderedTreeScopeSet::iterator end)
+void StyleEngine::clearMediaQueryRuleSetStyleSheets()
 {
-    for (UnorderedTreeScopeSet::iterator it = begin; it != end; ++it) {
-        TreeScope& treeScope = **it;
-        ASSERT(treeScope != m_document);
-        ShadowTreeStyleSheetCollection* collection = static_cast<ShadowTreeStyleSheetCollection*>(styleSheetCollectionFor(treeScope));
+    for (TreeScope* treeScope : TreeScope::TreeScopesWithActiveStyleSheetsTraversal(document())) {
+        TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(*treeScope);
+        ASSERT(collection);
+        collection->clearMediaQueryRuleSetStyleSheets();
+    }
+    for (TreeScope* treeScope : m_dirtyTreeScopes) {
+        TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(*treeScope);
         ASSERT(collection);
         collection->clearMediaQueryRuleSetStyleSheets();
     }
 }
 
-void StyleEngine::clearMediaQueryRuleSetStyleSheets()
-{
-    documentStyleSheetCollection()->clearMediaQueryRuleSetStyleSheets();
-    clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_activeTreeScopes.beginUnordered(), m_activeTreeScopes.endUnordered());
-    clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_dirtyTreeScopes.begin(), m_dirtyTreeScopes.end());
-}
-
 void StyleEngine::updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector)
 {
     ASSERT(!isMaster());
     WillBeHeapVector<RefPtrWillBeMember<StyleSheet>> sheetsForList;
     ImportedDocumentStyleSheetCollector subcollector(parentCollector, sheetsForList);
     documentStyleSheetCollection()->collectStyleSheets(*this, subcollector);
     documentStyleSheetCollection()->swapSheetsForSheetList(sheetsForList);
 }
 
-void StyleEngine::updateActiveStyleSheetsInShadow(StyleResolverUpdateMode updateMode, TreeScope* treeScope, UnorderedTreeScopeSet& treeScopesRemoved)
+void StyleEngine::updateActiveStyleSheetsInShadow(StyleResolverUpdateMode updateMode, TreeScope* treeScope, TreeScope::UnorderedTreeScopeSet& treeScopesRemoved)
 {
     ASSERT(treeScope != m_document);
     ShadowTreeStyleSheetCollection* collection = static_cast<ShadowTreeStyleSheetCollection*>(styleSheetCollectionFor(*treeScope));
     ASSERT(collection);
     collection->updateActiveStyleSheets(*this, updateMode);
     if (!collection->hasStyleSheetCandidateNodes()) {
-        treeScopesRemoved.add(treeScope);
+        if (treeScope->selfOrDescendantsHaveActiveStyleSheets() && !treeScope->hasChildTreeScopesWithActiveStyleSheets())
+            treeScopesRemoved.add(treeScope);
         // When removing TreeScope from ActiveTreeScopes,
         // its resolver should be destroyed by invoking resetAuthorStyle.
         ASSERT(!treeScope->scopedStyleResolver());
     }
 }
 
 void StyleEngine::updateActiveStyleSheets(StyleResolverUpdateMode updateMode)
 {
     ASSERT(isMaster());
     ASSERT(!document().inStyleRecalc());
 
     if (!document().isActive())
         return;
 
     if (shouldUpdateDocumentStyleSheetCollection(updateMode))
         documentStyleSheetCollection()->updateActiveStyleSheets(*this, updateMode);
 
     if (shouldUpdateShadowTreeStyleSheetCollection(updateMode)) {
-        UnorderedTreeScopeSet treeScopesRemoved;
-
+        TreeScope::UnorderedTreeScopeSet treeScopesRemoved;
         if (updateMode == FullStyleUpdate) {
-            for (unsigned i = 0; i < m_activeTreeScopes.size(); ++i)
-                updateActiveStyleSheetsInShadow(updateMode, m_activeTreeScopes[i], treeScopesRemoved);
+            for (TreeScope* treeScope : TreeScope::TreeScopesWithActiveStyleSheetsTraversal(document().childTreeScopesWithActiveStyleSheets()))
+                updateActiveStyleSheetsInShadow(updateMode, treeScope, treeScopesRemoved);
         } else {
-            for (UnorderedTreeScopeSet::iterator it = m_dirtyTreeScopes.begin(); it != m_dirtyTreeScopes.end(); ++it) {
-                updateActiveStyleSheetsInShadow(updateMode, *it, treeScopesRemoved);
+            for (TreeScope* treeScope : m_dirtyTreeScopes) {
+                updateActiveStyleSheetsInShadow(updateMode, treeScope, treeScopesRemoved);
             }
         }
-        for (UnorderedTreeScopeSet::iterator it = treeScopesRemoved.begin(); it != treeScopesRemoved.end(); ++it)
-            m_activeTreeScopes.remove(*it);
+        for (TreeScope* removed : treeScopesRemoved)
+            removed->clearSelfOrDescendantsHaveActiveStyleSheets();
     }
 
     InspectorInstrumentation::activeStyleSheetsUpdated(m_document);
     m_usesRemUnits = documentStyleSheetCollection()->usesRemUnits();
 
     m_dirtyTreeScopes.clear();
     m_documentScopeDirty = false;
 }
 
-const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>> StyleEngine::activeStyleSheetsForInspector() const
+const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>> StyleEngine::activeStyleSheetsForInspector()
 {
-    if (m_activeTreeScopes.isEmpty())
+    if (!document().hasChildTreeScopesWithActiveStyleSheets())
         return documentStyleSheetCollection()->activeAuthorStyleSheets();
 
     WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet>> activeStyleSheets;
-
-    activeStyleSheets.appendVector(documentStyleSheetCollection()->activeAuthorStyleSheets());
-    for (unsigned i = 0; i < m_activeTreeScopes.size(); ++i) {
-        TreeScope* treeScope = const_cast<TreeScope*>(m_activeTreeScopes[i]);
-        if (TreeScopeStyleSheetCollection* collection = m_styleSheetCollectionMap.get(treeScope))
+    for (TreeScope* treeScope : TreeScope::TreeScopesWithActiveStyleSheetsTraversal(document())) {
+        if (TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(*treeScope))
             activeStyleSheets.appendVector(collection->activeAuthorStyleSheets());
     }
 
     // FIXME: Inspector needs a vector which has all active stylesheets.
     // However, creating such a large vector might cause performance regression.
     // Need to implement some smarter solution.
     return activeStyleSheets;
 }
 
 void StyleEngine::didRemoveShadowRoot(ShadowRoot* shadowRoot)
 {
     m_styleSheetCollectionMap.remove(shadowRoot);
-    m_activeTreeScopes.remove(shadowRoot);
     m_dirtyTreeScopes.remove(shadowRoot);
 }
 
 void StyleEngine::shadowRootRemovedFromDocument(ShadowRoot* shadowRoot)
 {
     if (StyleResolver* styleResolver = resolver()) {
         styleResolver->resetAuthorStyle(*shadowRoot);
 
         if (TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(*shadowRoot))
             styleResolver->removePendingAuthorStyleSheets(collection->activeAuthorStyleSheets());
     }
     m_styleSheetCollectionMap.remove(shadowRoot);
-    m_activeTreeScopes.remove(shadowRoot);
     m_dirtyTreeScopes.remove(shadowRoot);
 }
 
 void StyleEngine::appendActiveAuthorStyleSheets()
 {
     ASSERT(isMaster());
 
-    m_resolver->appendAuthorStyleSheets(documentStyleSheetCollection()->activeAuthorStyleSheets());
-    for (unsigned i = 0; i < m_activeTreeScopes.size(); ++i) {
-        if (TreeScopeStyleSheetCollection* collection = m_styleSheetCollectionMap.get(m_activeTreeScopes[i]))
+    for (TreeScope* treeScope : TreeScope::TreeScopesWithActiveStyleSheetsTraversal(document())) {
+        if (TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(*treeScope))
             m_resolver->appendAuthorStyleSheets(collection->activeAuthorStyleSheets());
     }
     m_resolver->finishAppendAuthorStyleSheets();
 }
 
 void StyleEngine::createResolver()
 {
     // It is a programming error to attempt to resolve style on a Document
     // which is not in a frame. Code which hits this should have checked
     // Document::isActive() before calling into code which could get here.
 
     ASSERT(document().frame());
 
     m_resolver = adoptPtrWillBeNoop(new StyleResolver(*m_document));
 
     // A scoped style resolver for document will be created during
     // appendActiveAuthorStyleSheets if needed.
     appendActiveAuthorStyleSheets();
     combineCSSFeatureFlags(m_resolver->ensureUpdatedRuleFeatureSet());
 }
 
 void StyleEngine::clearResolver()
 {
     ASSERT(!document().inStyleRecalc());
     ASSERT(isMaster() || !m_resolver);
 
-    document().clearScopedStyleResolver();
     // StyleEngine::shadowRootRemovedFromDocument removes not-in-document
     // treescopes from activeTreeScopes. StyleEngine::didRemoveShadowRoot
     // removes treescopes which are being destroyed from activeTreeScopes.
     // So we need to clearScopedStyleResolver for treescopes which have been
     // just removed from document. If document is destroyed before invoking
     // updateActiveStyleSheets, the treescope has a scopedStyleResolver which
     // has destroyed StyleSheetContents.
-    for (UnorderedTreeScopeSet::iterator it = m_activeTreeScopes.beginUnordered(); it != m_activeTreeScopes.endUnordered(); ++it)
-        (*it)->clearScopedStyleResolver();
+    for (TreeScope* treeScope : TreeScope::TreeScopesWithActiveStyleSheetsTraversal(document()))
+        treeScope->clearScopedStyleResolver();
 
     m_resolver.clear();
 }
 
 void StyleEngine::clearMasterResolver()
 {
     if (Document* master = this->master())
         master->styleEngine().clearResolver();
 }
 
@@ skipping 146 matching lines @@
     if (it == m_sheetToTextCache.end())
         return;
 
     m_textToSheetCache.remove(it->value);
     m_sheetToTextCache.remove(contents);
 }
 
 void StyleEngine::collectScopedStyleFeaturesTo(RuleFeatureSet& features) const
 {
     HashSet<const StyleSheetContents*> visitedSharedStyleSheetContents;
-    if (document().scopedStyleResolver())
-        document().scopedStyleResolver()->collectFeaturesTo(features, visitedSharedStyleSheetContents);
-    for (unsigned i = 0; i < m_activeTreeScopes.size(); ++i) {
-        TreeScope* treeScope = const_cast<TreeScope*>(m_activeTreeScopes[i]);
+    for (TreeScope* treeScope : TreeScope::TreeScopesWithActiveStyleSheetsTraversal(document())) {
         // When creating StyleResolver, dirty treescopes might not be processed.
         // So some active treescopes might not have a scoped style resolver.
         // In this case, we should skip collectFeatures for the treescopes without
         // scoped style resolvers. When invoking updateActiveStyleSheets,
         // the treescope's features will be processed.
         if (ScopedStyleResolver* resolver = treeScope->scopedStyleResolver())
             resolver->collectFeaturesTo(features, visitedSharedStyleSheetContents);
     }
 }
 
@@ skipping 108 matching lines @@
 DEFINE_TRACE(StyleEngine)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_document);
     visitor->trace(m_authorStyleSheets);
     visitor->trace(m_documentStyleSheetCollection);
     visitor->trace(m_styleSheetCollectionMap);
     visitor->trace(m_resolver);
     visitor->trace(m_styleInvalidator);
     visitor->trace(m_dirtyTreeScopes);
-    visitor->trace(m_activeTreeScopes);
     visitor->trace(m_fontSelector);
     visitor->trace(m_textToSheetCache);
     visitor->trace(m_sheetToTextCache);
 #endif
     CSSFontSelectorClient::trace(visitor);
 }
 
 }