Add support for element ids in TargetedStyleRecalc

Source/core/css/RuleFeature.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.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 64 matching lines @@
     }
 
     inline bool hasSelectorForClass(const AtomicString& classValue) const
     {
         ASSERT(!classValue.isEmpty());
         return m_classInvalidationSets.get(classValue);
     }
 
     inline bool hasSelectorForId(const AtomicString& idValue) const
     {
-        return m_metadata.idsInRules.contains(idValue);
+        return m_idInvalidationSets.get(idValue);

[rune, 2014/04/01 06:58:26]

You assert on the emptiness of class and attribute above. Would it make sense to
do the same for id?

[chrishtr, 2014/04/01 16:25:16]

I think it can be empty, if the element has no id. There are also checks in
scheduleStyleInvalidationForIdChange for empty.

     }
 
     void scheduleStyleInvalidationForClassChange(const SpaceSplitString& changedClasses, Element&);
     void scheduleStyleInvalidationForClassChange(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, Element&);
 
     void scheduleStyleInvalidationForAttributeChange(const QualifiedName& attributeName, Element&);
 
+    void scheduleStyleInvalidationForIdChange(const AtomicString& oldId, const AtomicString& newId, Element&);
+
     int hasIdsInSelectors() const
     {
-        return m_metadata.idsInRules.size() > 0;
+        return m_idInvalidationSets.size() > 0;
     }
 
     // Marks the given attribute name as "appearing in a selector". Used for
     // CSS properties such as content: ... attr(...) ...
     // FIXME: record these internally to this class instead calls from StyleResolver to here.
     void addContentAttr(const AtomicString& attributeName);
 
     StyleInvalidator& styleInvalidator();
 
     Vector<RuleFeature> siblingRules;
     Vector<RuleFeature> uncommonAttributeRules;
 
 private:
     typedef HashMap<AtomicString, RefPtr<DescendantInvalidationSet> > InvalidationSetMap;
 
     struct FeatureMetadata {
         FeatureMetadata()
             : usesFirstLineRules(false)
             , foundSiblingSelector(false)
             , maxDirectAdjacentSelectors(0)
         { }
         void add(const FeatureMetadata& other);
         void clear();
 
         bool usesFirstLineRules;
         bool foundSiblingSelector;
         unsigned maxDirectAdjacentSelectors;
-        HashSet<AtomicString> idsInRules;
     };
 
     enum InvalidationSetMode {
         AddFeatures,
         UseLocalStyleChange,
         UseSubtreeStyleChange
     };
 
     static InvalidationSetMode supportsClassDescendantInvalidation(const CSSSelector&);
 
     void collectFeaturesFromSelector(const CSSSelector&, FeatureMetadata&, InvalidationSetMode);
     void collectFeaturesFromSelectorList(const CSSSelectorList*, FeatureMetadata&, InvalidationSetMode);
 
     DescendantInvalidationSet& ensureClassInvalidationSet(const AtomicString& className);
     DescendantInvalidationSet& ensureAttributeInvalidationSet(const AtomicString& attributeName);
+    DescendantInvalidationSet& ensureIdInvalidationSet(const AtomicString& attributeName);
     DescendantInvalidationSet* invalidationSetForSelector(const CSSSelector&);
 
     InvalidationSetMode updateInvalidationSets(const CSSSelector&);
 
     struct InvalidationSetFeatures {
         Vector<AtomicString> classes;
         Vector<AtomicString> attributes;
         AtomicString id;
         AtomicString tagName;
     };
 
     static void extractInvalidationSetFeature(const CSSSelector&, InvalidationSetFeatures&);
     const CSSSelector* extractInvalidationSetFeatures(const CSSSelector&, InvalidationSetFeatures&);
     void addFeaturesToInvalidationSets(const CSSSelector&, const InvalidationSetFeatures&);
 
     void addClassToInvalidationSet(const AtomicString& className, Element&);
 
     FeatureMetadata m_metadata;
     InvalidationSetMap m_classInvalidationSets;
     InvalidationSetMap m_attributeInvalidationSets;
+    InvalidationSetMap m_idInvalidationSets;
     bool m_targetedStyleRecalcEnabled;
     StyleInvalidator m_styleInvalidator;
 };
 
 
 } // namespace WebCore
 
 #endif // RuleFeature_h