Rename {Author,UserAgent}ShadowRoot to {Open,Closed}ShadowRoot.

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 52 matching lines @@
 
 SelectorChecker::SelectorChecker(Document& document, Mode mode)
     : m_strictParsing(!document.inQuirksMode())
     , m_mode(mode)
 {
 }
 
 static bool matchesCustomPseudoElement(const Element* element, const CSSSelector& selector)
 {
     ShadowRoot* root = element->containingShadowRoot();
-    if (!root || root->type() != ShadowRoot::UserAgentShadowRoot)
+    if (!root || root->type() != ShadowRoot::ClosedShadowRoot)
         return false;
 
     if (element->shadowPseudoId() != selector.value())
         return false;
 
     return true;
 }
 
 static Element* parentElement(const SelectorChecker::SelectorCheckingContext& context)
 {
@@ skipping 103 matching lines @@
 }
 
 static inline SelectorChecker::SelectorCheckingContext prepareNextContextForRelation(const SelectorChecker::SelectorCheckingContext& context)
 {
     SelectorChecker::SelectorCheckingContext nextContext(context);
     ASSERT(context.selector->tagHistory());
     nextContext.selector = context.selector->tagHistory();
     return nextContext;
 }
 
-static inline bool isAuthorShadowRoot(const Node* node)
+static inline bool isOpenShadowRoot(const Node* node)
 {
-    return node && node->isShadowRoot() && toShadowRoot(node)->type() == ShadowRoot::AuthorShadowRoot;
+    return node && node->isShadowRoot() && toShadowRoot(node)->type() == ShadowRoot::OpenShadowRoot;
 }
 
 template<typename SiblingTraversalStrategy>
 SelectorChecker::Match SelectorChecker::matchForSubSelector(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
 {
     SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
     PseudoId dynamicPseudo = result ? result->dynamicPseudo : NOPSEUDO;
     // a selector is invalid if something follows a pseudo-element
     // We make an exception for scrollbar pseudo elements and allow a set of pseudo classes (but nothing else)
     // to follow the pseudo elements.
     nextContext.hasScrollbarPseudo = dynamicPseudo != NOPSEUDO && (context.scrollbar || dynamicPseudo == SCROLLBAR_CORNER || dynamicPseudo == RESIZER);
     nextContext.hasSelectionPseudo = dynamicPseudo == SELECTION;
     if ((context.elementStyle || m_mode == CollectingCSSRules || m_mode == CollectingStyleRules || m_mode == QueryingRules) && dynamicPseudo != NOPSEUDO
         && !nextContext.hasSelectionPseudo
         && !(nextContext.hasScrollbarPseudo && nextContext.selector->match() == CSSSelector::PseudoClass))
         return SelectorFailsCompletely;
 
     nextContext.isSubSelector = true;
     return match(nextContext, siblingTraversalStrategy, result);
 }
 
 static bool selectorMatchesShadowRoot(const CSSSelector* selector)
 {
     return selector && selector->isShadowPseudoElement();
 }
 
-static inline Element* parentOrShadowHostButDisallowEscapingUserAgentShadowTree(const Element& element)
+static inline Element* parentOrShadowHostButDisallowEscapingClosedShadowTree(const Element& element)
 {
     ContainerNode* parent = element.parentOrShadowHostNode();
     if (!parent)
         return nullptr;
     if (parent->isShadowRoot())
-        return (toShadowRoot(parent)->type() == ShadowRoot::UserAgentShadowRoot) ? nullptr : toShadowRoot(parent)->host();
+        return (toShadowRoot(parent)->type() == ShadowRoot::ClosedShadowRoot) ? nullptr : toShadowRoot(parent)->host();
     if (!parent->isElementNode())
         return nullptr;
     return toElement(parent);
 }
 
 template<typename SiblingTraversalStrategy>
 SelectorChecker::Match SelectorChecker::matchForPseudoShadow(const ContainerNode* node, const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
 {
-    if (!isAuthorShadowRoot(node))
+    if (!isOpenShadowRoot(node))
         return SelectorFailsCompletely;
     return match(context, siblingTraversalStrategy, result);
 }
 
 template<typename SiblingTraversalStrategy>
 SelectorChecker::Match SelectorChecker::matchForRelation(const SelectorCheckingContext& context, const SiblingTraversalStrategy& siblingTraversalStrategy, MatchResult* result) const
 {
     SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
     nextContext.previousElement = context.element;
 
@@ skipping 91 matching lines @@
             nextContext.element = shadowHost;
             nextContext.isSubSelector = false;
             nextContext.elementStyle = 0;
             return this->match(nextContext, siblingTraversalStrategy, result);
         }
 
     case CSSSelector::ShadowDeep:
         {
             nextContext.isSubSelector = false;
             nextContext.elementStyle = 0;
-            for (nextContext.element = parentOrShadowHostButDisallowEscapingUserAgentShadowTree(*context.element); nextContext.element; nextContext.element = parentOrShadowHostButDisallowEscapingUserAgentShadowTree(*nextContext.element)) {
+            for (nextContext.element = parentOrShadowHostButDisallowEscapingClosedShadowTree(*context.element); nextContext.element; nextContext.element = parentOrShadowHostButDisallowEscapingClosedShadowTree(*nextContext.element)) {
                 Match match = this->match(nextContext, siblingTraversalStrategy, result);
                 if (match == SelectorMatches || match == SelectorFailsCompletely)
                     return match;
                 if (nextSelectorExceedsScope(nextContext))
                     return SelectorFailsCompletely;
             }
             return SelectorFailsCompletely;
         }
 
     case CSSSelector::SubSelector:
@@ skipping 821 matching lines @@
     return isHTMLSelectElement(element) && !toHTMLSelectElement(element).usesMenuList();
 }
 
 template
 SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext&, const DOMSiblingTraversalStrategy&, MatchResult*) const;
 
 template
 SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext&, const ShadowDOMSiblingTraversalStrategy&, MatchResult*) const;
 
 }