Make ScopedStyleResolver use apply-author-styles of a given element's treescope.

Source/core/css/resolver/ScopedStyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Google 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.
@@ skipping 75 matching lines @@
 
     // Since StyleResolver creates RuleSets according to styles' document
     // order, a parent of the given ScopedRuleData has been already
     // prepared.
     const ContainerNode* e = target->scope()->parentOrShadowHostNode();
     for (; e; e = e->parentOrShadowHostNode()) {
         if (ScopedStyleResolver* scopeResolver = scopedStyleResolverFor(e)) {
             target->setParent(scopeResolver);
             break;
         }
-        if (e->isShadowRoot() || e->isDocumentNode()) {
+        if (e->isDocumentNode()) {
             bool dummy;
             ScopedStyleResolver* scopeResolver = addScopedStyleResolver(e, dummy);
             target->setParent(scopeResolver);
             setupScopeStylesTree(scopeResolver);
             break;
         }
     }
 }
 
 void ScopedStyleTree::clear()
 {
     m_authorStyles.clear();
     m_scopeResolverForDocument = 0;
     m_cache.clear();
 }
 
-void ScopedStyleTree::resolveScopeStyles(const Element* element, Vector<std::pair<ScopedStyleResolver*, bool>, 8>& resolvers)
+void ScopedStyleTree::resolveScopeStyles(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers)
 {
     ScopedStyleResolver* scopeResolver = scopedResolverFor(element);
     if (!scopeResolver)
         return;
 
-    bool applyAuthorStylesOfElementTreeScope = element->treeScope()->applyAuthorStyles();
-    bool applyAuthorStyles = m_cache.authorStyleBoundsIndex == m_cache.scopeResolverBoundsIndex ? applyAuthorStylesOfElementTreeScope : false;
-
-    for ( ; scopeResolver; scopeResolver = scopeResolver->parent()) {
-        resolvers.append(std::pair<ScopedStyleResolver*, bool>(scopeResolver, applyAuthorStyles));
-        if (scopeResolver->scope()->isShadowRoot()) {
-            if (scopeResolver->parent()->scope()->isInShadowTree())
-                applyAuthorStyles = applyAuthorStyles && toShadowRoot(scopeResolver->scope())->applyAuthorStyles();
-            else
-                applyAuthorStyles = applyAuthorStylesOfElementTreeScope;
-        }
-    }
+    for ( ; scopeResolver; scopeResolver = scopeResolver->parent())

[hayato, 2013/05/29 11:16:27]

Now we can remove L115-L117, that can be merged to the 'for' loop.

for (ScopedStyleResolver* scopeResolver = scopedResolverFor(element);
scopeResolver; scopeResolver = scopeResolver->parent())

[tasak, 2013/05/31 10:06:58]

Done.

+        resolvers.append(scopeResolver);
 }
 
-inline ScopedStyleResolver* ScopedStyleTree::enclosingScopedStyleResolverFor(const ContainerNode* scope, int& authorStyleBoundsIndex)
+inline ScopedStyleResolver* ScopedStyleTree::enclosingScopedStyleResolverFor(const ContainerNode* scope)
 {
-    for (; scope; scope = scope->parentOrShadowHostNode()) {
+    for (; scope; scope = scope->parentOrShadowHostNode())
         if (ScopedStyleResolver* scopeStyleResolver = scopedStyleResolverFor(scope))
             return scopeStyleResolver;
-        if (scope->isShadowRoot() && !toShadowRoot(scope)->applyAuthorStyles())
-            --authorStyleBoundsIndex;
-    }
     return 0;
 }
 
 void ScopedStyleTree::resolveStyleCache(const ContainerNode* scope)
 {
-    int authorStyleBoundsIndex = 0;
-    m_cache.scopeResolver = enclosingScopedStyleResolverFor(scope, authorStyleBoundsIndex);
-    m_cache.scopeResolverBoundsIndex = authorStyleBoundsIndex;
+    m_cache.scopeResolver = enclosingScopedStyleResolverFor(scope);
     m_cache.nodeForScopeStyles = scope;
-    m_cache.authorStyleBoundsIndex = 0;
 }
 
 void ScopedStyleTree::pushStyleCache(const ContainerNode* scope, const ContainerNode* parent)
 {
     if (m_authorStyles.isEmpty())
         return;
 
     if (!cacheIsValid(parent)) {
         resolveStyleCache(scope);
         return;
     }
 
-    if (scope->isShadowRoot() && !toShadowRoot(scope)->applyAuthorStyles())
-        ++m_cache.authorStyleBoundsIndex;
-
     ScopedStyleResolver* scopeResolver = scopedStyleResolverFor(scope);
-    if (scopeResolver) {
+    if (scopeResolver)
         m_cache.scopeResolver = scopeResolver;
-        m_cache.scopeResolverBoundsIndex = m_cache.authorStyleBoundsIndex;
-    }
     m_cache.nodeForScopeStyles = scope;
 }
 
 void ScopedStyleTree::popStyleCache(const ContainerNode* scope)
 {
-    if (cacheIsValid(scope)) {
-        bool needUpdateBoundsIndex = scope->isShadowRoot() && !toShadowRoot(scope)->applyAuthorStyles();
+    if (!cacheIsValid(scope))
+        return;
 
-        if (m_cache.scopeResolver && m_cache.scopeResolver->scope() == scope) {
-            m_cache.scopeResolver = m_cache.scopeResolver->parent();
-            if (needUpdateBoundsIndex)
-                --m_cache.scopeResolverBoundsIndex;
-        }
-        if (needUpdateBoundsIndex)
-            --m_cache.authorStyleBoundsIndex;
-        m_cache.nodeForScopeStyles = scope->parentOrShadowHostNode();
-    }
+    if (m_cache.scopeResolver && m_cache.scopeResolver->scope() == scope)
+        m_cache.scopeResolver = m_cache.scopeResolver->parent();
+    m_cache.nodeForScopeStyles = scope->parentOrShadowHostNode();
 }
 
 void ScopedStyleTree::collectFeaturesTo(RuleFeatureSet& features)
 {
     for (HashMap<const ContainerNode*, OwnPtr<ScopedStyleResolver> >::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it)
         it->value->collectFeaturesTo(features);
 }
 
 void ScopedStyleTree::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
@@ skipping 155 matching lines @@
 }
 
 void ScopedStyleResolver::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CSS);
     info.addMember(m_authorStyle, "authorStyle");
     info.addMember(m_atHostRules, "atHostRules");
 }
 
 } // namespace WebCore