Use hash set instead of vector for changed RuleSets.

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

 // Copyright 2016 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/ActiveStyleSheets.h"
 
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/StyleSheetList.h"
@@ skipping 39 matching lines @@
   init.setMode("open");
   ShadowRoot* shadowRoot = host.attachShadow(
       ScriptState::forMainWorld(document().frame()), init, ASSERT_NO_EXCEPTION);
   EXPECT_TRUE(shadowRoot);
   return *shadowRoot;
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_NoChange) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   EXPECT_EQ(NoActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
   EXPECT_EQ(0u, changedRuleSets.size());
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
 
   EXPECT_EQ(NoActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
   EXPECT_EQ(0u, changedRuleSets.size());
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_AppendedToEmpty) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
 
   EXPECT_EQ(ActiveSheetsAppended,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
   EXPECT_EQ(2u, changedRuleSets.size());
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_AppendedToNonEmpty) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
 
   EXPECT_EQ(ActiveSheetsAppended,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
   EXPECT_EQ(1u, changedRuleSets.size());
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_Mutated) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
   CSSStyleSheet* sheet3 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   sheet2->contents()->clearRuleSet();
   sheet2->contents()->ensureRuleSet(MediaQueryEvaluator(),
                                     RuleHasDocumentSecurityOrigin);
 
   EXPECT_NE(oldSheets[1].second, &sheet2->contents()->ruleSet());
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   EXPECT_EQ(ActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
-  ASSERT_EQ(2u, changedRuleSets.size());
-  EXPECT_EQ(&sheet2->contents()->ruleSet(), changedRuleSets[0]);
-  EXPECT_EQ(oldSheets[1].second, changedRuleSets[1]);
+  EXPECT_EQ(2u, changedRuleSets.size());
+  EXPECT_TRUE(changedRuleSets.contains(&sheet2->contents()->ruleSet()));
+  EXPECT_TRUE(changedRuleSets.contains(oldSheets[1].second));
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_Inserted) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
   CSSStyleSheet* sheet3 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   EXPECT_EQ(ActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
-  ASSERT_EQ(1u, changedRuleSets.size());
-  EXPECT_EQ(&sheet2->contents()->ruleSet(), changedRuleSets[0]);
+  EXPECT_EQ(1u, changedRuleSets.size());
+  EXPECT_TRUE(changedRuleSets.contains(&sheet2->contents()->ruleSet()));
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_Removed) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
   CSSStyleSheet* sheet3 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   EXPECT_EQ(ActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
-  ASSERT_EQ(1u, changedRuleSets.size());
-  EXPECT_EQ(&sheet2->contents()->ruleSet(), changedRuleSets[0]);
+  EXPECT_EQ(1u, changedRuleSets.size());
+  EXPECT_TRUE(changedRuleSets.contains(&sheet2->contents()->ruleSet()));
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_RemovedAll) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
   CSSStyleSheet* sheet3 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   EXPECT_EQ(ActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
   EXPECT_EQ(3u, changedRuleSets.size());
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_InsertedAndRemoved) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
   CSSStyleSheet* sheet3 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
 
   newSheets.append(std::make_pair(sheet2, &sheet2->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   EXPECT_EQ(ActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
-  ASSERT_EQ(2u, changedRuleSets.size());
-  EXPECT_EQ(&sheet1->contents()->ruleSet(), changedRuleSets[0]);
-  EXPECT_EQ(&sheet3->contents()->ruleSet(), changedRuleSets[1]);
+  EXPECT_EQ(2u, changedRuleSets.size());
+  EXPECT_TRUE(changedRuleSets.contains(&sheet1->contents()->ruleSet()));
+  EXPECT_TRUE(changedRuleSets.contains(&sheet3->contents()->ruleSet()));
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_AddNullRuleSet) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet2, nullptr));
 
   EXPECT_EQ(NoActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
   EXPECT_EQ(0u, changedRuleSets.size());
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_RemoveNullRuleSet) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet2, nullptr));
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
 
   EXPECT_EQ(NoActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
   EXPECT_EQ(0u, changedRuleSets.size());
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_AddRemoveNullRuleSet) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
   CSSStyleSheet* sheet3 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet2, nullptr));
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet3, nullptr));
 
   EXPECT_EQ(NoActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
   EXPECT_EQ(0u, changedRuleSets.size());
 }
 
 TEST_F(ActiveStyleSheetsTest,
        CompareActiveStyleSheets_RemoveNullRuleSetAndAppend) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
   CSSStyleSheet* sheet3 = createSheet();
 
   oldSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   oldSheets.append(std::make_pair(sheet2, nullptr));
 
   newSheets.append(std::make_pair(sheet1, &sheet1->contents()->ruleSet()));
   newSheets.append(std::make_pair(sheet3, &sheet3->contents()->ruleSet()));
 
   EXPECT_EQ(ActiveSheetsChanged,
             compareActiveStyleSheets(oldSheets, newSheets, changedRuleSets));
-  ASSERT_EQ(1u, changedRuleSets.size());
-  EXPECT_EQ(&sheet3->contents()->ruleSet(), changedRuleSets[0]);
+  EXPECT_EQ(1u, changedRuleSets.size());
+  EXPECT_TRUE(changedRuleSets.contains(&sheet3->contents()->ruleSet()));
 }
 
 TEST_F(ActiveStyleSheetsTest, CompareActiveStyleSheets_ReorderedImportSheets) {
   ActiveStyleSheetVector oldSheets;
   ActiveStyleSheetVector newSheets;
-  HeapVector<Member<RuleSet>> changedRuleSets;
+  HeapHashSet<Member<RuleSet>> changedRuleSets;
 
   CSSStyleSheet* sheet1 = createSheet();
   CSSStyleSheet* sheet2 = createSheet();
 
   // It is possible to have CSSStyleSheet pointers re-orderered for html imports
   // because their documents, and hence their stylesheets are persisted on
   // remove / insert. This test is here to show that the active sheet comparison
   // is not able to see that anything changed.
   //
   // Imports are handled by forcing re-append and recalc of the document scope
@@ skipping 135 matching lines @@
   ActiveStyleSheetVector oldStyleSheets;
   oldStyleSheets.append(
       std::make_pair(cssSheet, &cssSheet->contents()->ruleSet()));
   styleEngine().applyRuleSetChanges(shadowRoot, oldStyleSheets,
                                     ActiveStyleSheetVector());
 
   EXPECT_TRUE(styleEngine().treeBoundaryCrossingScopes().isEmpty());
 }
 
 }  // namespace blink