Add support for new CSS ::slotted() pseudo element

third_party/WebKit/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 155 matching lines @@
         return false;
     }
 }
 
 bool supportsInvalidationWithSelectorList(CSSSelector::PseudoType pseudo)
 {
     return pseudo == CSSSelector::PseudoAny
         || pseudo == CSSSelector::PseudoCue
         || pseudo == CSSSelector::PseudoHost
         || pseudo == CSSSelector::PseudoHostContext
-        || pseudo == CSSSelector::PseudoNot;
+        || pseudo == CSSSelector::PseudoNot
+        || pseudo == CSSSelector::PseudoSlotted;
 }
 
 #endif // ENABLE(ASSERT)
 
 bool requiresSubtreeInvalidation(const CSSSelector& selector)
 {
     if (selector.match() != CSSSelector::PseudoElement && selector.match() != CSSSelector::PseudoClass) {
         ASSERT(supportsInvalidation(selector.match()));
         return false;
     }
 
     switch (selector.pseudoType()) {
     case CSSSelector::PseudoFirstLine:
     case CSSSelector::PseudoFirstLetter:
         // FIXME: Most pseudo classes/elements above can be supported and moved
         // to assertSupportedPseudo(). Move on a case-by-case basis. If they
         // require subtree invalidation, document why.
     case CSSSelector::PseudoHostContext:
         // :host-context matches a shadow host, yet the simple selectors inside
         // :host-context matches an ancestor of the shadow host.
+    case CSSSelector::PseudoSlotted:
+        // TODO(kochi): This recalculates a bit more than necessary. Find out a way
+        // to avoid unnecessary recalculation.

[rune, 2016/01/09 01:15:36]

This shouldn't be necessary as long as we extract the right invalidation set
features and set insertionPointCrossing correctly below.

         return true;
     default:
         ASSERT(supportsInvalidation(selector.pseudoType()));
         return false;
     }
 }
 
 template<class Map>
 InvalidationData& ensureInvalidationData(Map& map, const typename Map::KeyType& key)
 {
@@ skipping 258 matching lines @@
                 if (siblingFeatures == &descendantFeatures)
                     siblingInvalidationSet->descendants().setInvalidatesSelf();
                 else
                     addFeaturesToInvalidationSet(siblingInvalidationSet->descendants(), descendantFeatures);
             } else {
                 addFeaturesToInvalidationSet(*invalidationSet, descendantFeatures);
             }
         } else {
             if (current->isHostPseudoClass())
                 descendantFeatures.treeBoundaryCrossing = true;
-            if (current->isInsertionPointCrossing())
+            if (current->isInsertionPointCrossing() || current->isSlottedPseudoElement())
                 descendantFeatures.insertionPointCrossing = true;
             if (const CSSSelectorList* selectorList = current->selectorList()) {
                 ASSERT(supportsInvalidationWithSelectorList(current->pseudoType()));
                 for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(*subSelector))
                     addFeaturesToInvalidationSets(subSelector, siblingFeatures, descendantFeatures);
             }
         }
 
         if (current->relation() == CSSSelector::SubSelector)
             continue;
@@ skipping 184 matching lines @@
 
 DEFINE_TRACE(RuleFeatureSet)
 {
 #if ENABLE(OILPAN)
     visitor->trace(siblingRules);
     visitor->trace(uncommonAttributeRules);
 #endif
 }
 
 } // namespace blink