Fix unsafe handling of part object in RuleFeatureSetTest.

third_party/WebKit/Source/core/css/RuleFeatureSetTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/RuleFeature.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/RuleSet.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/invalidation/InvalidationSet.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/html/HTMLBodyElement.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLHtmlElement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
+// TODO(sof): consider making these part object helper abstractions
+// available from platform/heap/.
+
+template<typename T>
+class HeapPartObject final : public GarbageCollectedFinalized<HeapPartObject<T>> {
+public:
+    static HeapPartObject* create()
+    {
+        return new HeapPartObject;
+    }
+
+    T* get() { return &m_part; }
+
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_part);
+    }
+
+private:
+    HeapPartObject()
+    {
+    }
+
+    T m_part;
+};
+
+template<typename T>
+class PersistentPartObject final {
+    DISALLOW_NEW();
+public:
+    PersistentPartObject()
+        : m_part(HeapPartObject<T>::create())
+    {
+    }
+
+    T* operator->() const { return (*m_part).get(); }
+
+private:
+    Persistent<HeapPartObject<T>> m_part;
+};
+
 class RuleFeatureSetTest : public ::testing::Test {
 public:
     RuleFeatureSetTest()
     {
     }
 
     void SetUp()
     {
         m_document = HTMLDocument::create();
         HTMLHtmlElement* html = HTMLHtmlElement::create(*m_document);
         html->appendChild(HTMLBodyElement::create(*m_document));
         m_document->appendChild(html);
 
         m_document->body()->setInnerHTML("<b><i></i></b>", ASSERT_NO_EXCEPTION);
     }
 
     RuleFeatureSet::SelectorPreMatch collectFeatures(const String& selectorText)
     {
         CSSSelectorList selectorList = CSSParser::parseSelector(strictCSSParserContext(), nullptr, selectorText);
 
         StyleRule* styleRule = StyleRule::create(std::move(selectorList), MutableStylePropertySet::create(HTMLStandardMode));
         RuleData ruleData(styleRule, 0, 0, RuleHasNoSpecialState);
-        return m_ruleFeatureSet.collectFeaturesFromRuleData(ruleData);
+        return m_ruleFeatureSet->collectFeaturesFromRuleData(ruleData);
     }
 
     void collectInvalidationSetsForClass(InvalidationLists& invalidationLists, const AtomicString& className) const
     {
         Element* element = Traversal<HTMLElement>::firstChild(*Traversal<HTMLElement>::firstChild(*m_document->body()));
-        m_ruleFeatureSet.collectInvalidationSetsForClass(invalidationLists, *element, className);
+        m_ruleFeatureSet->collectInvalidationSetsForClass(invalidationLists, *element, className);
     }
 
     void collectInvalidationSetsForId(InvalidationLists& invalidationLists, const AtomicString& id) const
     {
         Element* element = Traversal<HTMLElement>::firstChild(*Traversal<HTMLElement>::firstChild(*m_document->body()));
-        m_ruleFeatureSet.collectInvalidationSetsForId(invalidationLists, *element, id);
+        m_ruleFeatureSet->collectInvalidationSetsForId(invalidationLists, *element, id);
     }
 
     void collectInvalidationSetsForAttribute(InvalidationLists& invalidationLists, const QualifiedName& attributeName) const
     {
         Element* element = Traversal<HTMLElement>::firstChild(*Traversal<HTMLElement>::firstChild(*m_document->body()));
-        m_ruleFeatureSet.collectInvalidationSetsForAttribute(invalidationLists, *element, attributeName);
+        m_ruleFeatureSet->collectInvalidationSetsForAttribute(invalidationLists, *element, attributeName);
     }
 
     void collectInvalidationSetsForPseudoClass(InvalidationLists& invalidationLists, CSSSelector::PseudoType pseudo) const
     {
         Element* element = Traversal<HTMLElement>::firstChild(*Traversal<HTMLElement>::firstChild(*m_document->body()));
-        m_ruleFeatureSet.collectInvalidationSetsForPseudoClass(invalidationLists, *element, pseudo);
+        m_ruleFeatureSet->collectInvalidationSetsForPseudoClass(invalidationLists, *element, pseudo);
     }
 
     const HashSet<AtomicString>& classSet(const InvalidationSet& invalidationSet)
     {
         return invalidationSet.classSetForTesting();
     }
 
     const HashSet<AtomicString>& idSet(const InvalidationSet& invalidationSet)
     {
         return invalidationSet.idSetForTesting();
@@ skipping 86 matching lines @@
     void expectAttributeInvalidation(const AtomicString& attribute, InvalidationSetVector& invalidationSets)
     {
         EXPECT_EQ(1u, invalidationSets.size());
         HashSet<AtomicString> attributes = attributeSet(*invalidationSets[0]);
         EXPECT_EQ(1u, attributes.size());
         EXPECT_TRUE(attributes.contains(attribute));
     }
 
     void expectSiblingRuleCount(unsigned count)
     {
-        EXPECT_EQ(count, m_ruleFeatureSet.siblingRules.size());
+        EXPECT_EQ(count, m_ruleFeatureSet->siblingRules.size());
     }
 
     void expectUncommonAttributeRuleCount(unsigned count)
     {
-        EXPECT_EQ(count, m_ruleFeatureSet.uncommonAttributeRules.size());
-    }
-
-    DEFINE_INLINE_TRACE()
-    {
-        visitor->trace(m_ruleFeatureSet);
-        visitor->trace(m_document);
+        EXPECT_EQ(count, m_ruleFeatureSet->uncommonAttributeRules.size());
     }
 
 private:
-    RuleFeatureSet m_ruleFeatureSet;
+    PersistentPartObject<RuleFeatureSet> m_ruleFeatureSet;
     Persistent<Document> m_document;
 };
 
 TEST_F(RuleFeatureSetTest, interleavedDescendantSibling1)
 {
     EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(".p"));
 
     InvalidationLists invalidationLists;
     collectInvalidationSetsForClass(invalidationLists, "p");
     expectSelfInvalidation(invalidationLists.descendants);
@@ skipping 326 matching lines @@
     expectUncommonAttributeRuleCount(1);
 }
 
 TEST_F(RuleFeatureSetTest, uncommonAttributeRulesAfterHostContextBeforePseudo)
 {
     EXPECT_EQ(RuleFeatureSet::SelectorMayMatch, collectFeatures(":host-context([attr])::before"));
     expectUncommonAttributeRuleCount(1);
 }
 
 } // namespace blink