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

third_party/WebKit/Source/core/css/SelectorChecker.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 29 matching lines @@
 #include "core/dom/shadow/ComposedTreeTraversal.h"
 #include "core/dom/shadow/InsertionPoint.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/FrameSelection.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLOptionElement.h"
 #include "core/html/HTMLSelectElement.h"
+#include "core/html/HTMLSlotElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/html/track/vtt/VTTElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutScrollbar.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "platform/scroll/ScrollbarTheme.h"
@@ skipping 46 matching lines @@
     // - If context.scope is a shadow root, we should walk up to its shadow host.
     // - If context.scope is some element in some shadow tree and querySelector initialized the context,
     //   e.g. shadowRoot.querySelector(':host *'),
     //   (a) context.element has the same treescope as context.scope, need to walk up to its shadow host.
     //   (b) Otherwise, should not walk up from a shadow root to a shadow host.
     if (context.scope && (context.scope == context.element->containingShadowRoot() || context.scope->treeScope() == context.element->treeScope()))
         return context.element->parentOrShadowHostElement();
     return context.element->parentElement();
 }
 
+static const HTMLSlotElement* findSlotElementInScope(const SelectorChecker::SelectorCheckingContext& context)
+{
+    if (!context.scope)
+        return nullptr;
+
+    const HTMLSlotElement* slot = context.element->assignedSlot();
+    while (slot) {
+        if (slot->treeScope() == context.scope->treeScope())
+            return slot;
+        slot = slot->assignedSlot();
+    }
+    return nullptr;
+}
+
 static bool scopeContainsLastMatchedElement(const SelectorChecker::SelectorCheckingContext& context)
 {
     // If this context isn't scoped, skip checking.
     if (!context.scope)
         return true;
 
     if (context.scope->treeScope() == context.element->treeScope())
         return true;
 
     // Because Blink treats a shadow host's TreeScope as a separate one from its descendent shadow roots,
@@ skipping 319 matching lines @@
             for (nextContext.element = parentOrV0ShadowHostElement(*context.element); nextContext.element; nextContext.element = parentOrV0ShadowHostElement(*nextContext.element)) {
                 Match match = matchSelector(nextContext, result);
                 if (match == SelectorMatches || match == SelectorFailsCompletely)
                     return match;
                 if (nextSelectorExceedsScope(nextContext))
                     return SelectorFailsCompletely;
             }
             return SelectorFailsCompletely;
         }
 
+    case CSSSelector::ShadowSlot:

[rune, 2016/01/11 10:07:23]

It's possible to implement this without this combinator and add the code below
to the PseudoSlotted handling instead. You only need to make sure PseudoSlotted
is listed first in the compound (which we already do in the parser to make sure
it ends up in a separate right-most compound) to make sure we match .slot for
the slot, not the slotted element, in .slot::slotted(.slotted).

+        {
+            const HTMLSlotElement* slot = findSlotElementInScope(context);
+            if (!slot)
+                return SelectorFailsCompletely;
+
+            nextContext.element = const_cast<HTMLSlotElement*>(slot);
+            return matchSelector(nextContext, result);
+        }
+
     case CSSSelector::SubSelector:
         ASSERT_NOT_REACHED();
     }
 
     ASSERT_NOT_REACHED();
     return SelectorFailsCompletely;
 }
 
 SelectorChecker::Match SelectorChecker::matchForShadowDistributed(const SelectorCheckingContext& context, const Element& element, MatchResult& result) const
 {
@@ skipping 551 matching lines @@
                     return true;
             }
             return false;
         }
     case CSSSelector::PseudoWebKitCustomElement:
         {
             if (ShadowRoot* root = element.containingShadowRoot())
                 return root->type() == ShadowRootType::UserAgent && element.shadowPseudoId() == selector.value();
             return false;
         }
+    case CSSSelector::PseudoSlotted:
+        {
+            SelectorCheckingContext subContext(context);
+            subContext.isSubSelector = true;
+            subContext.scope = nullptr;
+            subContext.treatShadowHostAsNormalScope = false;
+
+            // ::slotted() only allows one compound selector.
+            ASSERT(selector.selectorList()->first());
+            ASSERT(!CSSSelectorList::next(*selector.selectorList()->first()));
+            subContext.selector = selector.selectorList()->first();
+            return match(subContext);
+        }
     case CSSSelector::PseudoContent:
         return element.isInShadowTree() && element.isInsertionPoint();
     case CSSSelector::PseudoShadow:
         return element.isInShadowTree() && context.previousElement;
     default:
         break;
     }
 
     if (!context.inRightmostCompound && m_mode == ResolvingStyle)
         return false;
@@ skipping 154 matching lines @@
 }
 
 bool SelectorChecker::matchesFocusPseudoClass(const Element& element)
 {
     if (InspectorInstrumentation::forcePseudoState(const_cast<Element*>(&element), CSSSelector::PseudoFocus))
         return true;
     return element.focused() && isFrameFocused(element);
 }
 
 }