Sibling invalidation sets

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 "config.h"
+#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/InvalidationLists.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 <gtest/gtest.h>
+
+namespace blink {
+
+class RuleFeatureSetTest : public ::testing::Test {
+public:
+    RuleFeatureSetTest()
+    {
+    }
+
+    void SetUp()
+    {
+        m_document = HTMLDocument::create();
+        RefPtrWillBeRawPtr<HTMLHtmlElement> html = HTMLHtmlElement::create(*m_document);
+        html->appendChild(HTMLBodyElement::create(*m_document));
+        m_document->appendChild(html.release());
+
+        m_document->body()->setInnerHTML("<b><i></i></b>", ASSERT_NO_EXCEPTION);
+    }
+
+    void updateInvalidationSets(const String& selectorText)
+    {
+        CSSSelectorList selectorList;
+        CSSParser::parseSelector(strictCSSParserContext(), selectorText, selectorList);
+
+        RefPtrWillBeRawPtr<StyleRule> styleRule = StyleRule::create(selectorList, MutableStylePropertySet::create(HTMLStandardMode));
+        RuleData ruleData(styleRule.get(), 0, 0, RuleHasNoSpecialState);
+        m_ruleFeatureSet.updateInvalidationSets(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);
+    }
+
+    WillBeHeapHashSet<AtomicString>& ensureClassSet(InvalidationSet& invalidationSet)
+    {
+        return invalidationSet.ensureClassSet();
+    }
+
+    void expectNoInvalidation(InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(0u, invalidationSets.size());
+    }
+
+    void expectSelfInvalidation(InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        EXPECT_TRUE(invalidationSets[0]->isEmpty());
+    }
+
+    void expectClassInvalidation(const AtomicString& className, InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        WillBeHeapHashSet<AtomicString> classes = ensureClassSet(*invalidationSets[0]);
+        EXPECT_EQ(1u, classes.size());
+        EXPECT_TRUE(classes.contains(className));
+    }
+
+    void expectSiblingInvalidation(unsigned maxDirectAdjacentSelectors, const AtomicString& siblingName, InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        WillBeHeapHashSet<AtomicString> classes = ensureClassSet(*invalidationSets[0]);
+        EXPECT_EQ(1u, classes.size());
+        EXPECT_TRUE(classes.contains(siblingName));
+        EXPECT_EQ(maxDirectAdjacentSelectors, invalidationSets[0]->maxDirectAdjacentSelectors());
+    }
+
+    void expectSiblingDescendantInvalidation(unsigned maxDirectAdjacentSelectors, const AtomicString& siblingName, const AtomicString& descendantName, InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        WillBeHeapHashSet<AtomicString> classes = ensureClassSet(*invalidationSets[0]);
+        EXPECT_EQ(1u, classes.size());
+        EXPECT_TRUE(classes.contains(siblingName));
+        EXPECT_EQ(maxDirectAdjacentSelectors, invalidationSets[0]->maxDirectAdjacentSelectors());
+        EXPECT_FALSE(invalidationSets[0]->appliesDirectly());
+
+        WillBeHeapHashSet<AtomicString> descendantClasses = ensureClassSet(invalidationSets[0]->ensureDescendantInvalidationSet());
+        EXPECT_EQ(1u, descendantClasses.size());
+        EXPECT_TRUE(descendantClasses.contains(descendantName));
+    }
+
+    void expectClassesInvalidation(const AtomicString& firstClassName, const AtomicString& secondClassName, InvalidationSetVector& invalidationSets)
+    {
+        EXPECT_EQ(1u, invalidationSets.size());
+        WillBeHeapHashSet<AtomicString> classes = ensureClassSet(*invalidationSets[0]);
+        EXPECT_EQ(2u, classes.size());
+        EXPECT_TRUE(classes.contains(firstClassName));
+        EXPECT_TRUE(classes.contains(secondClassName));
+    }
+
+    DEFINE_INLINE_TRACE()
+    {
+#if ENABLE(OILPAN)
+        visitor->trace(m_ruleFeatureSet);
+        visitor->trace(m_document);
+#endif
+    }
+
+private:
+    RuleFeatureSet m_ruleFeatureSet;
+    RefPtrWillBePersistent<Document> m_document;
+};
+
+TEST_F(RuleFeatureSetTest, interleavedDescendantSibling)
+{
+    updateInvalidationSets(".k > .l ~ .m + .n .o + .p");
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "k");
+        expectClassInvalidation("p", invalidationLists.descendants());
+        expectNoInvalidation(invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "l");
+        expectNoInvalidation(invalidationLists.descendants());
+        expectSiblingDescendantInvalidation(std::numeric_limits<unsigned>::max(), "n", "p", invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "m");
+        expectNoInvalidation(invalidationLists.descendants());
+        expectSiblingDescendantInvalidation(1, "n", "p", invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "n");
+        expectClassInvalidation("p", invalidationLists.descendants());
+        expectNoInvalidation(invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "o");
+        expectNoInvalidation(invalidationLists.descendants());
+        expectSiblingInvalidation(1, "p", invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "p");
+        expectSelfInvalidation(invalidationLists.descendants());
+        expectNoInvalidation(invalidationLists.siblings());
+    }
+}
+
+TEST_F(RuleFeatureSetTest, anySibling)
+{
+    updateInvalidationSets(":-webkit-any(.q, .r) ~ .s .t");
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "q");
+        expectNoInvalidation(invalidationLists.descendants());
+        expectSiblingDescendantInvalidation(std::numeric_limits<unsigned>::max(), "s", "t", invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "r");
+        expectNoInvalidation(invalidationLists.descendants());
+        expectSiblingDescendantInvalidation(std::numeric_limits<unsigned>::max(), "s", "t", invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "s");
+        expectClassInvalidation("t", invalidationLists.descendants());
+        expectNoInvalidation(invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "t");
+        expectSelfInvalidation(invalidationLists.descendants());
+        expectNoInvalidation(invalidationLists.siblings());
+    }
+}
+
+TEST_F(RuleFeatureSetTest, siblingAny)
+{
+    updateInvalidationSets(".u .v ~ :-webkit-any(.w, .x)");
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "u");
+        expectClassesInvalidation("w", "x", invalidationLists.descendants());
+        expectNoInvalidation(invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "v");
+        expectNoInvalidation(invalidationLists.descendants());
+        expectClassesInvalidation("w", "x", invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "w");
+        expectSelfInvalidation(invalidationLists.descendants());
+        expectNoInvalidation(invalidationLists.siblings());
+    }
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "x");
+        expectSelfInvalidation(invalidationLists.descendants());
+        expectNoInvalidation(invalidationLists.siblings());
+    }
+}
+
+TEST_F(RuleFeatureSetTest, adjacentUniversal)
+{
+    updateInvalidationSets(".a + *");
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "a");
+        expectNoInvalidation(invalidationLists.descendants());
+        EXPECT_EQ(1u, invalidationLists.siblings().size());
+        InvalidationSet& invalidationSet = *invalidationLists.siblings()[0];
+        EXPECT_EQ(1U, invalidationSet.maxDirectAdjacentSelectors());
+        EXPECT_TRUE(invalidationSet.appliesDirectly());
+        EXPECT_TRUE(invalidationSet.wholeSubtreeInvalid());
+        EXPECT_EQ(nullptr, invalidationSet.descendants());
+    }
+}
+
+TEST_F(RuleFeatureSetTest, siblingDescendantNegation)
+{
+    updateInvalidationSets(".a ~ .b :not(.c)");
+    {
+        InvalidationLists invalidationLists;
+        collectInvalidationSetsForClass(invalidationLists, "a");
+        expectNoInvalidation(invalidationLists.descendants());
+        expectSiblingInvalidation(std::numeric_limits<unsigned>::max(), "b", invalidationLists.siblings());
+
+        InvalidationSet& siblingInvalidationSet = *invalidationLists.siblings()[0];
+
+        EXPECT_FALSE(siblingInvalidationSet.appliesDirectly());
+        EXPECT_NE(nullptr, siblingInvalidationSet.descendants());
+        const InvalidationSet& siblingDescendant = *siblingInvalidationSet.descendants();
+        EXPECT_TRUE(siblingDescendant.wholeSubtreeInvalid());
+    }
+}
+
+} // namespace blink