Have ScopedStyleResolver deal with ContainerNode references, not pointers

Source/core/css/resolver/ScopedStyleResolver.h

 /*
  * 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 32 matching lines @@
 class ElementRuleCollector;
 class MediaQueryEvaluator;
 class PageRuleCollector;
 class ShadowRoot;
 class StyleSheetContents;
 
 // This class selects a RenderStyle for a given element based on a collection of stylesheets.
 class ScopedStyleResolver {
     WTF_MAKE_NONCOPYABLE(ScopedStyleResolver); WTF_MAKE_FAST_ALLOCATED;
 public:
-    static PassOwnPtr<ScopedStyleResolver> create(const ContainerNode* scopingNode) { return adoptPtr(new ScopedStyleResolver(scopingNode)); }
+    static PassOwnPtr<ScopedStyleResolver> create(const ContainerNode& scopingNode) { return adoptPtr(new ScopedStyleResolver(scopingNode)); }
 
     static const ContainerNode* scopingNodeFor(const CSSStyleSheet*);
 
-    const ContainerNode* scopingNode() const { return m_scopingNode; }
-    const TreeScope* treeScope() const { return m_scopingNode->treeScope(); }
+    const ContainerNode& scopingNode() const { return m_scopingNode; }
+    const TreeScope* treeScope() const { return m_scopingNode.treeScope(); }
     void prepareEmptyRuleSet() { m_authorStyle = RuleSet::create(); }
     void setParent(ScopedStyleResolver* newParent) { m_parent = newParent; }
     ScopedStyleResolver* parent() { return m_parent; }
 
     bool hasOnlyEmptyRuleSets() const { return !m_authorStyle->ruleCount() && m_atHostRules.isEmpty(); }
 
 public:
     bool checkRegionStyle(Element*);
     const StyleRuleKeyframes* keyframeStylesForAnimation(const StringImpl* animationName);
     void addKeyframeStyle(PassRefPtr<StyleRuleKeyframes>);
 
     void matchHostRules(ElementRuleCollector&, bool includeEmptyRules);
     void matchAuthorRules(ElementRuleCollector&, bool includeEmptyRules, bool applyAuthorStyles);
     void collectMatchingAuthorRules(ElementRuleCollector&, bool includeEmptyRules, bool applyAuthorStyles, CascadeScope, CascadeOrder = ignoreCascadeOrder);
     void matchPageRules(PageRuleCollector&);
     void addRulesFromSheet(StyleSheetContents*, const MediaQueryEvaluator&, StyleResolver*);
     void addHostRule(StyleRuleHost*, bool hasDocumentSecurityOrigin, const ContainerNode* scopingNode);
     void collectFeaturesTo(RuleFeatureSet&);
     void resetAuthorStyle();
     void resetAtHostRules(const ShadowRoot*);
     void collectViewportRulesTo(StyleResolver*) const;
 
 private:
-    ScopedStyleResolver() : m_scopingNode(0), m_parent(0) { }
-    ScopedStyleResolver(const ContainerNode* scopingNode) : m_scopingNode(scopingNode), m_parent(0) { }
+    explicit ScopedStyleResolver(const ContainerNode& scopingNode) : m_scopingNode(scopingNode), m_parent(0) { }
 
     RuleSet* ensureAtHostRuleSetFor(const ShadowRoot*);
     RuleSet* atHostRuleSetFor(const ShadowRoot*) const;
 
-    const ContainerNode* m_scopingNode;
+    const ContainerNode& m_scopingNode;
     ScopedStyleResolver* m_parent;
 
     OwnPtr<RuleSet> m_authorStyle;
     HashMap<const ShadowRoot*, OwnPtr<RuleSet> > m_atHostRules;
 
     typedef HashMap<const StringImpl*, RefPtr<StyleRuleKeyframes> > KeyframesRuleMap;
     KeyframesRuleMap m_keyframesRuleMap;
 };
 
 class ScopedStyleTree {
     WTF_MAKE_NONCOPYABLE(ScopedStyleTree); WTF_MAKE_FAST_ALLOCATED;
 public:
     ScopedStyleTree() : m_scopedResolverForDocument(0), m_buildInDocumentOrder(true) { }
 
-    ScopedStyleResolver* ensureScopedStyleResolver(const ContainerNode* scopingNode);
-    ScopedStyleResolver* scopedStyleResolverFor(const ContainerNode* scopingNode);
-    ScopedStyleResolver* addScopedStyleResolver(const ContainerNode* scopingNode, bool& isNewEntry);
+    ScopedStyleResolver* ensureScopedStyleResolver(const ContainerNode& scopingNode);
+    ScopedStyleResolver* scopedStyleResolverFor(const ContainerNode& scopingNode);
+    ScopedStyleResolver* addScopedStyleResolver(const ContainerNode& scopingNode, bool& isNewEntry);
     void clear();
 
     // for fast-path.
     bool hasOnlyScopedResolverForDocument() const { return m_scopedResolverForDocument && m_authorStyles.size() == 1; }
     ScopedStyleResolver* scopedStyleResolverForDocument() { return m_scopedResolverForDocument; }
 
     void resolveScopedStyles(const Element*, Vector<ScopedStyleResolver*, 8>&);
     void collectScopedResolversForHostedShadowTrees(const Element*, Vector<ScopedStyleResolver*, 8>&);
     void resolveScopedKeyframesRules(const Element*, Vector<ScopedStyleResolver*, 8>&);
     ScopedStyleResolver* scopedResolverFor(const Element*);
 
     void remove(const ContainerNode* scopingNode);
 
-    void pushStyleCache(const ContainerNode* scopingNode, const ContainerNode* parent);
-    void popStyleCache(const ContainerNode* scopingNode);
+    void pushStyleCache(const ContainerNode& scopingNode, const ContainerNode* parent);
+    void popStyleCache(const ContainerNode& scopingNode);
 
     void collectFeaturesTo(RuleFeatureSet& features);
     void setBuildInDocumentOrder(bool enabled) { m_buildInDocumentOrder = enabled; }
     bool buildInDocumentOrder() const { return m_buildInDocumentOrder; }
 
 private:
     void setupScopedStylesTree(ScopedStyleResolver* target);
 
     bool cacheIsValid(const ContainerNode* parent) const { return parent && parent == m_cache.nodeForScopedStyles; }
     void resolveStyleCache(const ContainerNode* scopingNode);
@@ skipping 23 matching lines @@
 {
     if (!cacheIsValid(element))
         resolveStyleCache(element);
 
     return m_cache.scopedResolver;
 }
 
 } // namespace WebCore
 
 #endif // ScopedStyleResolver_h