Make siblingRules and uncommonAttributeRules private.

third_party/WebKit/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.
  *
@@ skipping 58 matching lines @@
   RuleFeatureSet();
   ~RuleFeatureSet();
 
   void add(const RuleFeatureSet&);
   void clear();
 
   enum SelectorPreMatch { SelectorNeverMatches, SelectorMayMatch };
 
   SelectorPreMatch collectFeaturesFromRuleData(const RuleData&);
 
-  bool usesSiblingRules() const { return !siblingRules.isEmpty(); }
+  bool usesSiblingRules() const { return !m_siblingRules.isEmpty(); }
   bool usesFirstLineRules() const { return m_metadata.usesFirstLineRules; }
   bool usesWindowInactiveSelector() const {
     return m_metadata.usesWindowInactiveSelector;
   }
   bool needsFullRecalcForRuleSetInvalidation() const {
     return m_metadata.needsFullRecalcForRuleSetInvalidation;
   }
 
   unsigned maxDirectAdjacentSelectors() const {
     return m_metadata.maxDirectAdjacentSelectors;
   }
 
   bool hasSelectorForAttribute(const AtomicString& attributeName) const {
     DCHECK(!attributeName.isEmpty());
     return m_attributeInvalidationSets.contains(attributeName);
   }
 
   bool hasSelectorForClass(const AtomicString& classValue) const {
     DCHECK(!classValue.isEmpty());
     return m_classInvalidationSets.contains(classValue);
   }
 
   bool hasSelectorForId(const AtomicString& idValue) const {
     return m_idInvalidationSets.contains(idValue);
   }
 
+  const HeapVector<RuleFeature>& siblingRules() const { return m_siblingRules; }
+  const HeapVector<RuleFeature>& uncommonAttributeRules() const {
+    return m_uncommonAttributeRules;
+  }
+
   // Collect descendant and sibling invalidation sets.
   void collectInvalidationSetsForClass(InvalidationLists&,
                                        Element&,
                                        const AtomicString& className) const;
   void collectInvalidationSetsForId(InvalidationLists&,
                                     Element&,
                                     const AtomicString& id) const;
   void collectInvalidationSetsForAttribute(
       InvalidationLists&,
       Element&,
@@ skipping 16 matching lines @@
       const QualifiedName& attributeName,
       unsigned minDirectAdjacent) const;
   void collectUniversalSiblingInvalidationSet(InvalidationLists&,
                                               unsigned minDirectAdjacent) const;
   void collectNthInvalidationSet(InvalidationLists&) const;
 
   bool hasIdsInSelectors() const { return m_idInvalidationSets.size() > 0; }
 
   DECLARE_TRACE();
 
-  HeapVector<RuleFeature> siblingRules;
-  HeapVector<RuleFeature> uncommonAttributeRules;
-
   bool isAlive() const { return m_isAlive; }
 
  protected:
   InvalidationSet* invalidationSetForSimpleSelector(const CSSSelector&,
                                                     InvalidationType);
 
  private:
   // Each map entry is either a DescendantInvalidationSet or
   // SiblingInvalidationSet.
   // When both are needed, we store the SiblingInvalidationSet, and use it to
@@ skipping 111 matching lines @@
 
   void addClassToInvalidationSet(const AtomicString& className, Element&);
 
   FeatureMetadata m_metadata;
   InvalidationSetMap m_classInvalidationSets;
   InvalidationSetMap m_attributeInvalidationSets;
   InvalidationSetMap m_idInvalidationSets;
   PseudoTypeInvalidationSetMap m_pseudoInvalidationSets;
   RefPtr<SiblingInvalidationSet> m_universalSiblingInvalidationSet;
   RefPtr<DescendantInvalidationSet> m_nthInvalidationSet;
+  HeapVector<RuleFeature> m_siblingRules;
+  HeapVector<RuleFeature> m_uncommonAttributeRules;
 
   // If true, the RuleFeatureSet is alive and can be used.
   unsigned m_isAlive : 1;
 
   friend class RuleFeatureSetTest;
 };
 
 }  // namespace blink
 
 #endif  // RuleFeature_h