Move ScopedStyleResolver and ScopedStyleTree to oilpan's heap

Source/core/css/resolver/ScopedStyleTree.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 24 matching lines @@
 namespace blink {
 
 class StyleSheetContents;
 
 ScopedStyleTree::ScopedStyleTree()
 {
 }
 
 ScopedStyleTree::~ScopedStyleTree()
 {
-    for (HashMap<const ContainerNode*, ScopedStyleResolver*>::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it)
+#if !ENABLE(OILPAN)
+    for (HashMap<RawPtr<const ContainerNode>, RawPtr<ScopedStyleResolver> >::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it)
         it->key->treeScope().clearScopedStyleResolver();
+#endif
 }
 
 ScopedStyleResolver* ScopedStyleTree::ensureScopedStyleResolver(ContainerNode& scopingNode)
 {
     ASSERT(scopingNode.isShadowRoot() || scopingNode.isDocumentNode());
 
     m_authorStyles.add(&scopingNode, &scopingNode.treeScope().ensureScopedStyleResolver());
     return scopingNode.treeScope().scopedStyleResolver();
 }
 
 ScopedStyleResolver* ScopedStyleTree::scopedStyleResolverFor(const ContainerNode& scopingNode)
 {
     if (!isShadowHost(&scopingNode)
         && !scopingNode.isDocumentNode()
         && !scopingNode.isShadowRoot())
         return 0;
     return scopingNode.treeScope().scopedStyleResolver();
 }
 
-void ScopedStyleTree::resolveScopedStyles(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers)
+void ScopedStyleTree::resolveScopedStyles(const Element* element, WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8>& resolvers)
 {
     for (ScopedStyleResolver* scopedResolver = scopedResolverFor(element); scopedResolver; scopedResolver = scopedResolver->parent())
         resolvers.append(scopedResolver);
 }
 
-void ScopedStyleTree::collectScopedResolversForHostedShadowTrees(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers)
+void ScopedStyleTree::collectScopedResolversForHostedShadowTrees(const Element* element, WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8>& resolvers)
 {
     ElementShadow* shadow = element->shadow();
     if (!shadow)
         return;
 
     // Adding scoped resolver for active shadow roots for shadow host styling.
     for (ShadowRoot* shadowRoot = shadow->youngestShadowRoot(); shadowRoot; shadowRoot = shadowRoot->olderShadowRoot()) {
         if (shadowRoot->numberOfStyles() > 0) {
             if (ScopedStyleResolver* resolver = scopedStyleResolverFor(*shadowRoot))
                 resolvers.append(resolver);
         }
     }
 }
 
-void ScopedStyleTree::resolveScopedKeyframesRules(const Element* element, Vector<ScopedStyleResolver*, 8>& resolvers)
+void ScopedStyleTree::resolveScopedKeyframesRules(const Element* element, WillBeHeapVector<RawPtrWillBeMember<ScopedStyleResolver>, 8>& resolvers)
 {
     Document& document = element->document();
     TreeScope& treeScope = element->treeScope();
     bool applyAuthorStyles = treeScope.applyAuthorStyles();
 
     // Add resolvers for shadow roots hosted by the given element.
     collectScopedResolversForHostedShadowTrees(element, resolvers);
 
     // Add resolvers while walking up DOM tree from the given element.
     for (ScopedStyleResolver* scopedResolver = scopedResolverFor(element); scopedResolver; scopedResolver = scopedResolver->parent()) {
@@ skipping 39 matching lines @@
         return;
 
     if (m_cache.scopedResolver && m_cache.scopedResolver->scopingNode() == scopingNode)
         m_cache.scopedResolver = m_cache.scopedResolver->parent();
     m_cache.nodeForScopedStyles = scopingNode.parentOrShadowHostNode();
 }
 
 void ScopedStyleTree::collectFeaturesTo(RuleFeatureSet& features)
 {
     HashSet<const StyleSheetContents*> visitedSharedStyleSheetContents;
-    for (HashMap<const ContainerNode*, ScopedStyleResolver*>::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it)
+    for (WillBeHeapHashMap<RawPtrWillBeMember<const ContainerNode>, RawPtrWillBeMember<ScopedStyleResolver> >::iterator it = m_authorStyles.begin(); it != m_authorStyles.end(); ++it)
         it->value->collectFeaturesTo(features, visitedSharedStyleSheetContents);
 }
 
 void ScopedStyleTree::remove(const ContainerNode* scopingNode)
 {
     if (!scopingNode || scopingNode->isDocumentNode())
         return;
 
     ScopedStyleResolver* resolver = scopingNode->treeScope().scopedStyleResolver();
     if (!resolver)
         return;
 
     if (m_cache.scopedResolver == resolver)
         m_cache.clear();
 
     // resolver is going to be freed below.
     resolver = 0;
     m_authorStyles.remove(scopingNode);
     scopingNode->treeScope().clearScopedStyleResolver();
 }
 
+void ScopedStyleTree::trace(Visitor* visitor)
+{
+    visitor->trace(m_authorStyles);
+    visitor->trace(m_cache);
+}
+
 } // namespace blink