Have ScopedStyleResolver deal with ContainerNode references, not pointers

Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 166 matching lines @@
 
     if (document().renderer() && document().renderer()->style())
         document().renderer()->style()->font().update(fontSelector());
 
     if (RuntimeEnabledFeatures::cssViewportEnabled())
         collectViewportRules();
 }
 
 void StyleResolver::resetAuthorStyle(const ContainerNode* scopingNode)
 {
-    ScopedStyleResolver* resolver = scopingNode ? m_styleTree.scopedStyleResolverFor(scopingNode) : m_styleTree.scopedStyleResolverForDocument();
+    ScopedStyleResolver* resolver = scopingNode ? m_styleTree.scopedStyleResolverFor(*scopingNode) : m_styleTree.scopedStyleResolverForDocument();
     if (!resolver)
         return;
 
     m_ruleSets.shadowDistributedRules().reset(scopingNode);
 
     resolver->resetAuthorStyle();
     if (!scopingNode)
         return;
 
     if (scopingNode->isShadowRoot())
         resetAtHostRules(scopingNode);
 
     if (!resolver->hasOnlyEmptyRuleSets())
         return;
 
     m_styleTree.remove(scopingNode);
 }
 
 void StyleResolver::resetAtHostRules(const ContainerNode* scopingNode)
 {
     ASSERT(scopingNode);
     ASSERT(scopingNode->isShadowRoot());
 
     const ShadowRoot* shadowRoot = toShadowRoot(scopingNode);
     const ContainerNode* shadowHost = shadowRoot->shadowHost();
-    ScopedStyleResolver* resolver = m_styleTree.scopedStyleResolverFor(shadowHost);
+    ASSERT(shadowHost);
+    ScopedStyleResolver* resolver = m_styleTree.scopedStyleResolverFor(*shadowHost);
     if (!resolver)
         return;
 
     resolver->resetAtHostRules(shadowRoot);
     if (!resolver->hasOnlyEmptyRuleSets())
         return;
 
     m_styleTree.remove(shadowHost);
 }
 
@@ skipping 13 matching lines @@
     m_features.clear();
     m_ruleSets.collectFeaturesTo(m_features, document().isViewSource());
     m_styleTree.collectFeaturesTo(m_features);
 
     m_siblingRuleSet = makeRuleSet(m_features.siblingRules);
     m_uncommonAttributeRuleSet = makeRuleSet(m_features.uncommonAttributeRules);
 }
 
 void StyleResolver::pushParentElement(Element* parent)
 {
+    ASSERT(parent);
     const ContainerNode* parentsParent = parent->parentOrShadowHostElement();
 
     // We are not always invoked consistently. For example, script execution can cause us to enter
     // style recalc in the middle of tree building. We may also be invoked from somewhere within the tree.
     // Reset the stack in this case, or if we see a new root element.
     // Otherwise just push the new parent.
     if (!parentsParent || m_selectorFilter.parentStackIsEmpty())
         m_selectorFilter.setupParentStack(parent);
     else
         m_selectorFilter.pushParent(parent);
 
     // Note: We mustn't skip ShadowRoot nodes for the scope stack.
-    m_styleTree.pushStyleCache(parent, parent->parentOrShadowHostNode());
+    m_styleTree.pushStyleCache(*parent, parent->parentOrShadowHostNode());
 }
 
 void StyleResolver::popParentElement(Element* parent)
 {
+    ASSERT(parent);
     // Note that we may get invoked for some random elements in some wacky cases during style resolve.
     // Pause maintaining the stack in this case.
     if (m_selectorFilter.parentStackIsConsistent(parent))
         m_selectorFilter.popParent();
 
-    m_styleTree.popStyleCache(parent);
+    m_styleTree.popStyleCache(*parent);
 }
 
-void StyleResolver::pushParentShadowRoot(const ShadowRoot* shadowRoot)
+void StyleResolver::pushParentShadowRoot(const ShadowRoot& shadowRoot)
 {
-    ASSERT(shadowRoot->host());
-    m_styleTree.pushStyleCache(shadowRoot, shadowRoot->host());
+    ASSERT(shadowRoot.host());
+    m_styleTree.pushStyleCache(shadowRoot, shadowRoot.host());
 }
 
-void StyleResolver::popParentShadowRoot(const ShadowRoot* shadowRoot)
+void StyleResolver::popParentShadowRoot(const ShadowRoot& shadowRoot)
 {
-    ASSERT(shadowRoot->host());
+    ASSERT(shadowRoot.host());
     m_styleTree.popStyleCache(shadowRoot);
 }
 
 StyleResolver::~StyleResolver()
 {
     m_fontSelector->clearDocument();
     m_viewportStyleResolver->clearDocument();
 }
 
 inline void StyleResolver::matchShadowDistributedRules(ElementRuleCollector& collector, bool includeEmptyRules)
@@ skipping 18 matching lines @@
     for (size_t i = 0; i < matchRequests.size(); ++i)
         collector.collectMatchingRules(matchRequests[i], ruleRange, cascadeScope);
     collector.sortAndTransferMatchedRules();
 
     collector.setBehaviorAtBoundary(previousBoundary);
     collector.setCanUseFastReject(previousCanUseFastReject);
 }
 
 void StyleResolver::matchHostRules(Element* element, ScopedStyleResolver* resolver, ElementRuleCollector& collector, bool includeEmptyRules)
 {
-    if (element != resolver->scopingNode())
+    if (element != &resolver->scopingNode())
         return;
     resolver->matchHostRules(collector, includeEmptyRules);
 }
 
 static inline bool applyAuthorStylesOf(const Element* element)
 {
     return element->treeScope()->applyAuthorStyles() || (element->shadow() && element->shadow()->applyAuthorStyles());
 }
 
 void StyleResolver::matchScopedAuthorRulesForShadowHost(Element* element, ElementRuleCollector& collector, bool includeEmptyRules, Vector<ScopedStyleResolver*, 8>& resolvers, Vector<ScopedStyleResolver*, 8>& resolversInShadowTree)
@@ skipping 42 matching lines @@
 
     bool applyAuthorStyles = applyAuthorStylesOf(element);
     CascadeScope cascadeScope = 0;
     CascadeOrder cascadeOrder = resolvers.size();
     collector.clearMatchedRules();
     collector.matchedResult().ranges.lastAuthorRule = collector.matchedResult().matchedProperties.size() - 1;
 
     for (unsigned i = 0; i < resolvers.size(); ++i, --cascadeOrder) {
         ScopedStyleResolver* resolver = resolvers.at(i);
         // FIXME: Need to clarify how to treat style scoped.
-        resolver->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope++, resolver->treeScope() == element->treeScope() && resolver->scopingNode()->isShadowRoot() ? 0 : cascadeOrder);
+        resolver->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope++, resolver->treeScope() == element->treeScope() && resolver->scopingNode().isShadowRoot() ? 0 : cascadeOrder);
     }
 
     collector.sortAndTransferMatchedRules();
 
     matchHostRules(element, resolvers.first(), collector, includeEmptyRules);
 }
 
 void StyleResolver::matchAuthorRules(Element* element, ElementRuleCollector& collector, bool includeEmptyRules)
 {
     matchScopedAuthorRules(element, collector, includeEmptyRules);
@@ skipping 1157 matching lines @@
         m_matchedPropertiesSearches, m_matchedPropertiesHit, m_matchedPropertiesSharedInheritedHit, m_matchedPropertiesToCache, m_matchedPropertiesEnteredIntoCache);
 
     fprintf(stderr, "Total:\n");
     printStyleStats(m_totalSearches, m_totalElementsEligibleForSharing, m_totalStylesShared, m_totalSearchFoundSiblingForSharing, m_totalSearchesMissedSharing,
         m_totalMatchedPropertiesSearches, m_totalMatchedPropertiesHit, m_totalMatchedPropertiesSharedInheritedHit, m_totalMatchedPropertiesToCache, m_totalMatchedPropertiesEnteredIntoCache);
     fprintf(stderr, "--------------------------------------------------------------------------------\n");
 }
 #endif
 
 } // namespace WebCore