1 /* 2 * Copyright (C) 1999 Lars Knoll (knoll (at) kde.org) 3 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved. 4 * Copyright (C) 2012 Google Inc. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY 16 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 18 * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY 19 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 20 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 22 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 24 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include "config.h" 28 #include "core/css/resolver/ScopedStyleTree.h" 29 30 #include "core/css/RuleFeature.h" 31 #include "core/dom/Document.h" 32 #include "core/dom/shadow/ElementShadow.h" 33 #include "core/dom/shadow/ShadowRoot.h" 34 35 namespace WebCore { 36 37 class StyleSheetContents; 38 39 ScopedStyleResolver* ScopedStyleTree::ensureScopedStyleResolver(ContainerNode& scopingNode) 40 { 41 bool isNewEntry; 42 ScopedStyleResolver* scopedStyleResolver = addScopedStyleResolver(scopingNode, isNewEntry); 43 if (isNewEntry) 44 setupScopedStylesTree(scopedStyleResolver); 45 return scopedStyleResolver; 46 } 47 48 ScopedStyleResolver* ScopedStyleTree::scopedStyleResolverFor(const ContainerNode& scopingNode) 49 { 50 if (!isShadowHost(&scopingNode) 51 && !scopingNode.isDocumentNode() 52 && !scopingNode.isShadowRoot()) 53 return 0; 54 return lookupScopedStyleResolverFor(&scopingNode); 55 } 56 57 ScopedStyleResolver* ScopedStyleTree::addScopedStyleResolver(ContainerNode& scopingNode, bool& isNewEntry) 58 { 59 HashMap<const ContainerNode*, OwnPtr<ScopedStyleResolver> >::AddResult addResult = m_authorStyles.add(&scopingNode, nullptr); 60 61 if (addResult.isNewEntry) { 62 addResult.storedValue->value = ScopedStyleResolver::create(scopingNode); 63 if (scopingNode.isDocumentNode()) 64 m_scopedResolverForDocument = addResult.storedValue->value.get(); 65 } 66 isNewEntry = addResult.isNewEntry; 67 return addResult.storedValue->value.get(); 68 } 69 70 void ScopedStyleTree::setupScopedStylesTree(ScopedStyleResolver* target) 71 { 72 ASSERT(target); 73 74 const ContainerNode& scopingNode = target->scopingNode(); 75 76 // Since StyleResolver creates RuleSets according to styles' document 77 // order, a parent of the given ScopedRuleData has been already 78 // prepared. 79 for (ContainerNode* node = scopingNode.parentOrShadowHostNode(); node; node = node->parentOrShadowHostNode()) { 80 if (ScopedStyleResolver* scopedResolver = scopedStyleResolverFor(*node)) { 81 target->setParent(scopedResolver); 82 break; 83 } 84 if (node->isDocumentNode()) { 85 bool dummy; 86 ScopedStyleResolver* scopedResolver = addScopedStyleResolver(*node, dummy); 87 target->setParent(scopedResolver); 88 setupScopedStylesTree(scopedResolver); 89 break; 90 } 91 } 92 93 if (m_buildInDocumentOrder) 94 return; 95 96 // Reparent all nodes whose scoping node is contained by target's one. 97 for (HashMap<const ContainerNode*, OwnPtr<ScopedStyleResolver> >::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it) { 98 if (it->value == target) 99 continue; 100 ASSERT(it->key->inDocument()); 101 if (it->value->parent() == target->parent() && scopingNode.containsIncludingShadowDOM(it->key)) 102 it->value->setParent(target); 103 } 104 } 105 106 void ScopedStyleTree::clear() 107 { 108 m_authorStyles.clear(); 109 m_scopedResolverForDocument = 0; 110 m_cache.clear(); 111 } 112 113 void ScopedStyleTree::resolveScopedStyles(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers) 114 { 115 for (ScopedStyleResolver* scopedResolver = scopedResolverFor(element); scopedResolver; scopedResolver = scopedResolver->parent()) 116 resolvers.append(scopedResolver); 117 } 118 119 void ScopedStyleTree::collectScopedResolversForHostedShadowTrees(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers) 120 { 121 ElementShadow* shadow = element->shadow(); 122 if (!shadow) 123 return; 124 125 // Adding scoped resolver for active shadow roots for shadow host styling. 126 for (ShadowRoot* shadowRoot = shadow->youngestShadowRoot(); shadowRoot; shadowRoot = shadowRoot->olderShadowRoot()) { 127 if (shadowRoot->numberOfStyles() > 0) { 128 if (ScopedStyleResolver* resolver = scopedStyleResolverFor(*shadowRoot)) 129 resolvers.append(resolver); 130 } 131 } 132 } 133 134 void ScopedStyleTree::resolveScopedKeyframesRules(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers) 135 { 136 Document& document = element->document(); 137 TreeScope& treeScope = element->treeScope(); 138 bool applyAuthorStyles = treeScope.applyAuthorStyles(); 139 140 // Add resolvers for shadow roots hosted by the given element. 141 collectScopedResolversForHostedShadowTrees(element, resolvers); 142 143 // Add resolvers while walking up DOM tree from the given element. 144 for (ScopedStyleResolver* scopedResolver = scopedResolverFor(element); scopedResolver; scopedResolver = scopedResolver->parent()) { 145 if (scopedResolver->treeScope() == treeScope || (applyAuthorStyles && scopedResolver->treeScope() == document)) 146 resolvers.append(scopedResolver); 147 } 148 } 149 150 inline ScopedStyleResolver* ScopedStyleTree::enclosingScopedStyleResolverFor(const ContainerNode* scopingNode) 151 { 152 for (; scopingNode; scopingNode = scopingNode->parentOrShadowHostNode()) { 153 if (ScopedStyleResolver* scopedStyleResolver = scopedStyleResolverFor(*scopingNode)) 154 return scopedStyleResolver; 155 } 156 return 0; 157 } 158 159 void ScopedStyleTree::resolveStyleCache(const ContainerNode* scopingNode) 160 { 161 m_cache.scopedResolver = enclosingScopedStyleResolverFor(scopingNode); 162 m_cache.nodeForScopedStyles = scopingNode; 163 } 164 165 void ScopedStyleTree::pushStyleCache(const ContainerNode& scopingNode, const ContainerNode* parent) 166 { 167 if (m_authorStyles.isEmpty()) 168 return; 169 170 if (!cacheIsValid(parent)) { 171 resolveStyleCache(&scopingNode); 172 return; 173 } 174 175 ScopedStyleResolver* scopedResolver = scopedStyleResolverFor(scopingNode); 176 if (scopedResolver) 177 m_cache.scopedResolver = scopedResolver; 178 m_cache.nodeForScopedStyles = &scopingNode; 179 } 180 181 void ScopedStyleTree::popStyleCache(const ContainerNode& scopingNode) 182 { 183 if (!cacheIsValid(&scopingNode)) 184 return; 185 186 if (m_cache.scopedResolver && m_cache.scopedResolver->scopingNode() == scopingNode) 187 m_cache.scopedResolver = m_cache.scopedResolver->parent(); 188 m_cache.nodeForScopedStyles = scopingNode.parentOrShadowHostNode(); 189 } 190 191 void ScopedStyleTree::collectFeaturesTo(RuleFeatureSet& features) 192 { 193 HashSet<const StyleSheetContents*> visitedSharedStyleSheetContents; 194 for (HashMap<const ContainerNode*, OwnPtr<ScopedStyleResolver> >::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it) 195 it->value->collectFeaturesTo(features, visitedSharedStyleSheetContents); 196 } 197 198 inline void ScopedStyleTree::reparentNodes(const ScopedStyleResolver* oldParent, ScopedStyleResolver* newParent) 199 { 200 // FIXME: this takes O(N) (N = number of all scoping nodes). 201 for (HashMap<const ContainerNode*, OwnPtr<ScopedStyleResolver> >::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it) { 202 if (it->value->parent() == oldParent) 203 it->value->setParent(newParent); 204 } 205 } 206 207 void ScopedStyleTree::remove(const ContainerNode* scopingNode) 208 { 209 if (!scopingNode || scopingNode->isDocumentNode()) 210 return; 211 212 ScopedStyleResolver* resolverRemoved = lookupScopedStyleResolverFor(scopingNode); 213 if (!resolverRemoved) 214 return; 215 216 reparentNodes(resolverRemoved, resolverRemoved->parent()); 217 if (m_cache.scopedResolver == resolverRemoved) 218 m_cache.clear(); 219 220 m_authorStyles.remove(scopingNode); 221 } 222 223 } // namespace WebCore 224