Use the HashSet of attribute names in SharedStyleFinder.

sky/engine/core/css/resolver/SharedStyleFinder.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 30 matching lines @@
 #include "sky/engine/core/dom/SpaceSplitString.h"
 #include "sky/engine/core/dom/shadow/ElementShadow.h"
 #include "sky/engine/core/dom/shadow/InsertionPoint.h"
 #include "sky/engine/core/html/HTMLElement.h"
 #include "sky/engine/core/rendering/style/RenderStyle.h"
 #include "sky/engine/wtf/HashSet.h"
 #include "sky/engine/wtf/text/AtomicString.h"
 
 namespace blink {
 
-bool SharedStyleFinder::classNamesAffectedByRules(const SpaceSplitString& classNames) const
+bool SharedStyleFinder::classNamesAffectedByRules(const Element& element) const
 {
+    const SpaceSplitString& classNames = element.classNames();
     unsigned count = classNames.size();
     for (unsigned i = 0; i < count; ++i) {
         if (m_features.hasSelectorForClass(classNames[i]))
             return true;
     }
     return false;
 }
 
+bool SharedStyleFinder::attributesAffectedByRules(const Element& element) const
+{
+    AttributeCollection attributes = element.attributesWithoutUpdate();
+    AttributeCollection::iterator end = attributes.end();
+    for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {

[ojan, 2014/12/10 23:22:58]

Can you use C++11 iterators here? I think the syntax would be:
for (auto& attribute : element.attributesWithoutUpdate()) {

+        if (m_features.hasSelectorForAttribute(it->localName()))
+            return true;
+    }
+    return false;
+}
+
 bool SharedStyleFinder::sharingCandidateHasIdenticalStyleAffectingAttributes(Element& candidate) const
 {
     if (element().sharesSameElementData(candidate))
         return true;
     if (element().getAttribute(HTMLNames::langAttr) != candidate.getAttribute(HTMLNames::langAttr))
         return false;
 
     if (!m_elementAffectedByClassRules) {
-        if (candidate.hasClass() && classNamesAffectedByRules(candidate.classNames()))
+        if (candidate.hasClass() && classNamesAffectedByRules(candidate))
             return false;
     } else if (candidate.hasClass()) {
         if (element().classNames() != candidate.classNames())
             return false;
     } else {
         return false;
     }
 
     return true;
 }
@@ skipping 89 matching lines @@
             // Move the element to the front of the LRU
             styleSharingList.remove(it);
             styleSharingList.prepend(&candidate);
         }
         return &candidate;
     }
     m_styleResolver.addToStyleSharingList(element());
     return 0;
 }
 
-bool SharedStyleFinder::matchesRuleSet(RuleSet* ruleSet)
-{
-    if (!ruleSet)
-        return false;
-    ElementRuleCollector collector(m_context);
-    return collector.hasAnyMatchingRules(ruleSet);
-}
-
 RenderStyle* SharedStyleFinder::findSharedStyle()
 {
     INCREMENT_STYLE_STATS_COUNTER(m_styleResolver, sharedStyleLookups);
 
     if (!element().supportsStyleSharing())
         return 0;
 
+    if (attributesAffectedByRules(element())) {
+        INCREMENT_STYLE_STATS_COUNTER(m_styleResolver, sharedStyleRejectedByAttributeRules);
+        return 0;
+    }
+
     // Cache whether context.element() is affected by any known class selectors.
-    m_elementAffectedByClassRules = element().hasClass() && classNamesAffectedByRules(element().classNames());
+    m_elementAffectedByClassRules = element().hasClass() && classNamesAffectedByRules(element());
 
     Element* shareElement = findElementForStyleSharing();
 
     if (!shareElement) {
         if (m_styleResolver.stats() && m_styleResolver.stats()->printMissedCandidateCount && documentContainsValidCandidate())
             INCREMENT_STYLE_STATS_COUNTER(m_styleResolver, sharedStyleMissed);
         return 0;
     }
 
     INCREMENT_STYLE_STATS_COUNTER(m_styleResolver, sharedStyleFound);
 
-    if (matchesRuleSet(m_attributeRuleSet)) {
+    if (attributesAffectedByRules(*shareElement)) {
         INCREMENT_STYLE_STATS_COUNTER(m_styleResolver, sharedStyleRejectedByAttributeRules);
         return 0;
     }
 
     return shareElement->renderStyle();
 }
 
 }