All selectors in :-webkit-any must have an invalidation set feature.

Source/core/css/RuleFeature.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 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 108 matching lines @@
 // This method is somewhat conservative in what it accepts.
 RuleFeatureSet::InvalidationSetMode RuleFeatureSet::invalidationSetModeForSelector(const CSSSelector& selector)
 {
     bool foundCombinator = false;
     bool foundIdent = false;
     for (const CSSSelector* component = &selector; component; component = component->tagHistory()) {
 
         if (component->match() == CSSSelector::Class || component->match() == CSSSelector::Id
             || (component->match() == CSSSelector::Tag && component->tagQName().localName() != starAtom)
             || component->isAttributeSelector() || component->isCustomPseudoElement()) {
-            if (!foundCombinator)
+            if (!foundCombinator) {
+                // We have found an invalidation set feature in the rightmost compound selector.
                 foundIdent = true;
+            }
         } else if (component->pseudoType() == CSSSelector::PseudoHost || component->pseudoType() == CSSSelector::PseudoAny) {
             if (const CSSSelectorList* selectorList = component->selectorList()) {
+                bool foundUniversal = false;
                 for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(*selector)) {
-                    InvalidationSetMode hostMode = invalidationSetModeForSelector(*selector);
-                    if (hostMode == UseSubtreeStyleChange)
+                    // Find the invalidation set mode for each of the selectors in the selector list
+                    // of a :not(), :host(), etc. For instance, ".x :-webkit-any(.a, .b)" yields an
+                    // AddFeatures mode for both ".a" and ".b". ":-webkit-any(.a, *)" yields AddFeatures
+                    // for ".a", but UseSubtreeStyleChange for "*". One sub-selector without invalidation
+                    // set features is sufficient to cause the selector to be a universal selector as far
+                    // the invalidation set is concerned.
+                    InvalidationSetMode subSelectorMode = invalidationSetModeForSelector(*selector);
+
+                    // The sub-selector contained something unskippable, fall back to whole subtree
+                    // recalcs in collectFeaturesFromSelector.
+                    if (subSelectorMode == UseSubtreeStyleChange)
                         return foundCombinator ? UseLocalStyleChange : UseSubtreeStyleChange;

[chrishtr, 2014/07/11 18:14:08]

Please explain in the comment why it is sometimes allowed to return
UseLocalStyleChange.

[rune, 2014/07/11 21:02:57]

I have to investigate why the _UseSubtreeStyleChange_ is still needed. The
returned value from this method is the input to the collectFeaturesFromSelector
method which does the fallback for adding invalidation set features.
UseLocalStyleChange there means just create invalidation sets for the features
found in the rightmost compound to do a LocalStyleChange when any of those
features change, but start to use SubtreeStyleChange once we go past the first
combinator. So, if the features in the rightmost compound are ok, we can clearly
UseLocalStyleChange. I can't think of what type of selector found in the
rightmost compound selector will require a SubtreeStyleChange for any of its
features.

[rune, 2014/07/11 21:49:37]

Done.

-                    if (!foundCombinator && hostMode == AddFeatures)
-                        foundIdent = true;
+
+                    // We found no features in the sub-selector, only skippable ones (foundIdent was
+                    // false at the end of this method). That is a universal selector as far as the
+                    // invalidation set is concerned.
+                    if (subSelectorMode == UseLocalStyleChange)
+                        foundUniversal = true;
+                }
+                if (!foundUniversal && !foundCombinator) {
+                    // All sub-selectors contained invalidation set features and
+                    // we are in the rightmost compound selector.
+                    foundIdent = true;
                 }
             }
         } else if (!isSkippableComponentForInvalidation(*component)) {
             return foundCombinator ? UseLocalStyleChange : UseSubtreeStyleChange;
         }
         if (component->relation() != CSSSelector::SubSelector)
             foundCombinator = true;
     }
     return foundIdent ? AddFeatures : UseLocalStyleChange;
 }
@@ skipping 357 matching lines @@
     visitor->trace(siblingRules);
     visitor->trace(uncommonAttributeRules);
     visitor->trace(m_classInvalidationSets);
     visitor->trace(m_attributeInvalidationSets);
     visitor->trace(m_idInvalidationSets);
     visitor->trace(m_pseudoInvalidationSets);
     visitor->trace(m_styleInvalidator);
 }
 
 } // namespace WebCore