Reflow comments in core/css

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) 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) 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.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 76 matching lines @@
     if (element.tagQName().localNameUpper() != tagQName.localNameUpper())
       return false;
   }
   const AtomicString& namespaceURI = tagQName.namespaceURI();
   return namespaceURI == starAtom || namespaceURI == element.namespaceURI();
 }
 
 static Element* parentElement(
     const SelectorChecker::SelectorCheckingContext& context) {
   // - 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.
+  // - 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) {
@@ skipping 11 matching lines @@
 
 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,
-  // if the last matched element is a shadow host, the condition above isn't met, even though it
-  // should be.
+  // Because Blink treats a shadow host's TreeScope as a separate one from its
+  // descendent shadow roots, if the last matched element is a shadow host, the
+  // condition above isn't met, even though it should be.
   return context.element == context.scope->ownerShadowHost() &&
          (!context.previousElement ||
           context.previousElement->isInDescendantTreeOf(context.element));
 }
 
 static inline bool nextSelectorExceedsScope(
     const SelectorChecker::SelectorCheckingContext& context) {
   if (context.scope && context.scope->isInShadowTree())
     return context.element == context.scope->ownerShadowHost();
 
   return false;
 }
 
 static bool shouldMatchHoverOrActive(
     const SelectorChecker::SelectorCheckingContext& context) {
-  // If we're in quirks mode, then :hover and :active should never match anchors with no
-  // href and *:hover and *:active should not match anything. This is specified in
-  // https://quirks.spec.whatwg.org/#the-:active-and-:hover-quirk
+  // If we're in quirks mode, then :hover and :active should never match anchors
+  // with no href and *:hover and *:active should not match anything. This is
+  // specified in https://quirks.spec.whatwg.org/#the-:active-and-:hover-quirk
   if (!context.element->document().inQuirksMode())
     return true;
   if (context.isSubSelector)
     return true;
   if (context.element->isLink())
     return true;
   const CSSSelector* selector = context.selector;
   while (selector->relation() == CSSSelector::SubSelector &&
          selector->tagHistory()) {
     selector = selector->tagHistory();
@@ skipping 20 matching lines @@
 
 static bool isLastOfType(Element& element, const QualifiedName& type) {
   return !ElementTraversal::nextSibling(element, HasTagName(type));
 }
 
 // Recursive check of selectors and combinators
 // It can return 4 different values:
 // * SelectorMatches          - the selector matches the element e
 // * SelectorFailsLocally     - the selector fails for the element e
 // * SelectorFailsAllSiblings - the selector fails for e and any sibling of e
-// * SelectorFailsCompletely  - the selector fails for e and any sibling or ancestor of e
+// * SelectorFailsCompletely  - the selector fails for e and any sibling or
+//   ancestor of e
 SelectorChecker::Match SelectorChecker::matchSelector(
     const SelectorCheckingContext& context,
     MatchResult& result) const {
   MatchResult subResult;
   if (!checkOne(context, subResult))
     return SelectorFailsLocally;
 
   if (subResult.dynamicPseudo != PseudoIdNone)
     result.dynamicPseudo = subResult.dynamicPseudo;
 
@@ skipping 21 matching lines @@
   }
   if (match == SelectorMatches)
     result.specificity += subResult.specificity;
   return match;
 }
 
 static inline SelectorChecker::SelectorCheckingContext
 prepareNextContextForRelation(
     const SelectorChecker::SelectorCheckingContext& context) {
   SelectorChecker::SelectorCheckingContext nextContext(context);
-  ASSERT(context.selector->tagHistory());
+  DCHECK(context.selector->tagHistory());
   nextContext.selector = context.selector->tagHistory();
   return nextContext;
 }
 
 SelectorChecker::Match SelectorChecker::matchForSubSelector(
     const SelectorCheckingContext& context,
     MatchResult& result) const {
   SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
   PseudoId dynamicPseudo = result.dynamicPseudo;
@@ skipping 30 matching lines @@
   return element.parentOrShadowHostElement();
 }
 
 SelectorChecker::Match SelectorChecker::matchForRelation(
     const SelectorCheckingContext& context,
     MatchResult& result) const {
   SelectorCheckingContext nextContext = prepareNextContextForRelation(context);
 
   CSSSelector::RelationType relation = context.selector->relation();
 
-  // Disable :visited matching when we see the first link or try to match anything else than an ancestors.
+  // Disable :visited matching when we see the first link or try to match
+  // anything else than an ancestors.
   if (!context.isSubSelector &&
       (context.element->isLink() ||
        (relation != CSSSelector::Descendant && relation != CSSSelector::Child)))
     nextContext.visitedMatchType = VisitedMatchDisabled;
 
   nextContext.inRightmostCompound = false;
   nextContext.isSubSelector = false;
   nextContext.previousElement = context.element;
   nextContext.pseudoId = PseudoIdNone;
 
@@ skipping 69 matching lines @@
             match == SelectorFailsCompletely)
           return match;
       }
       return SelectorFailsAllSiblings;
 
     case CSSSelector::ShadowPseudo: {
       if (!m_isUARule && !m_isQuerySelector &&
           context.selector->getPseudoType() == CSSSelector::PseudoShadow)
         Deprecation::countDeprecation(context.element->document(),
                                       UseCounter::CSSSelectorPseudoShadow);
-      // If we're in the same tree-scope as the scoping element, then following a shadow descendant combinator would escape that and thus the scope.
+      // If we're in the same tree-scope as the scoping element, then following
+      // a shadow descendant combinator would escape that and thus the scope.
       if (context.scope && context.scope->ownerShadowHost() &&
           context.scope->ownerShadowHost()->treeScope() ==
               context.element->treeScope())
         return SelectorFailsCompletely;
 
       Element* shadowHost = context.element->ownerShadowHost();
       if (!shadowHost)
         return SelectorFailsCompletely;
       nextContext.element = shadowHost;
       return matchSelector(nextContext, result);
     }
 
     case CSSSelector::ShadowDeep: {
       if (!m_isUARule && !m_isQuerySelector)
         Deprecation::countDeprecation(context.element->document(),
                                       UseCounter::CSSDeepCombinator);
       if (ShadowRoot* root = context.element->containingShadowRoot()) {
         if (root->type() == ShadowRootType::UserAgent)
           return SelectorFailsCompletely;
       }
 
       if (context.selector->relationIsAffectedByPseudoContent()) {
-        // TODO(kochi): closed mode tree should be handled as well for ::content.
+        // TODO(kochi): closed mode tree should be handled as well for
+        // ::content.
         for (Element* element = context.element; element;
              element = element->parentOrShadowHostElement()) {
           if (matchForPseudoContent(nextContext, *element, result) ==
               SelectorMatches) {
             if (context.element->isInShadowTree())
               UseCounter::count(context.element->document(),
                                 UseCounter::CSSDeepCombinatorAndShadow);
             return SelectorMatches;
           }
         }
@@ skipping 21 matching lines @@
       if (!slot)
         return SelectorFailsCompletely;
 
       nextContext.element = const_cast<HTMLSlotElement*>(slot);
       return matchSelector(nextContext, result);
     }
 
     case CSSSelector::SubSelector:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SelectorFailsCompletely;
 }
 
 SelectorChecker::Match SelectorChecker::matchForPseudoContent(
     const SelectorCheckingContext& context,
     const Element& element,
     MatchResult& result) const {
   HeapVector<Member<InsertionPoint>, 8> insertionPoints;
   collectDestinationInsertionPoints(element, insertionPoints);
   SelectorCheckingContext nextContext(context);
@@ skipping 63 matching lines @@
       if (value.length() < selectorValue.length())
         return false;
       if (!value.startsWith(selectorValue, caseSensitivity))
         return false;
       // It they start the same, check for exact match or following '-':
       if (value.length() != selectorValue.length() &&
           value[selectorValue.length()] != '-')
         return false;
       return true;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return false;
   }
 }
 
 static bool anyAttributeMatches(Element& element,
                                 CSSSelector::MatchType match,
                                 const CSSSelector& selector) {
   const QualifiedName& selectorAttr = selector.attribute();
-  ASSERT(selectorAttr.localName() !=
-         starAtom);  // Should not be possible from the CSS grammar.
+  // Should not be possible from the CSS grammar.
+  DCHECK_NE(selectorAttr.localName(), starAtom);
 
   // Synchronize the attribute in case it is lazy-computed.
-  // Currently all lazy properties have a null namespace, so only pass localName().
+  // Currently all lazy properties have a null namespace, so only pass
+  // localName().
   element.synchronizeAttribute(selectorAttr.localName());
 
   const AtomicString& selectorValue = selector.value();
   TextCaseSensitivity caseSensitivity =
       (selector.attributeMatch() == CSSSelector::CaseInsensitive)
           ? TextCaseASCIIInsensitive
           : TextCaseSensitive;
 
   AttributeCollection attributes = element.attributesWithoutUpdate();
   for (const auto& attributeItem : attributes) {
@@ skipping 28 matching lines @@
     }
     if (selectorAttr.namespaceURI() != starAtom)
       return false;
   }
 
   return false;
 }
 
 bool SelectorChecker::checkOne(const SelectorCheckingContext& context,
                                MatchResult& result) const {
-  ASSERT(context.element);
+  DCHECK(context.element);
   Element& element = *context.element;
-  ASSERT(context.selector);
+  DCHECK(context.selector);
   const CSSSelector& selector = *context.selector;
 
-  // Only :host and :host-context() should match the host: http://drafts.csswg.org/css-scoping/#host-element
+  // Only :host and :host-context() should match the host:
+  // http://drafts.csswg.org/css-scoping/#host-element
   if (context.scope && context.scope->ownerShadowHost() == element &&
       (!selector.isHostPseudoClass() && !context.treatShadowHostAsNormalScope &&
        selector.match() != CSSSelector::PseudoElement))
     return false;
 
   switch (selector.match()) {
     case CSSSelector::Tag:
       return matchesTagName(element, selector.tagQName());
     case CSSSelector::Class:
       return element.hasClass() &&
@@ skipping 11 matching lines @@
     case CSSSelector::AttributeBegin:
     case CSSSelector::AttributeEnd:
       return anyAttributeMatches(element, selector.match(), selector);
 
     case CSSSelector::PseudoClass:
       return checkPseudoClass(context, result);
     case CSSSelector::PseudoElement:
       return checkPseudoElement(context, result);
 
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return false;
   }
 }
 
 bool SelectorChecker::checkPseudoNot(const SelectorCheckingContext& context,
                                      MatchResult& result) const {
   const CSSSelector& selector = *context.selector;
 
   SelectorCheckingContext subContext(context);
   subContext.isSubSelector = true;
-  ASSERT(selector.selectorList());
+  DCHECK(selector.selectorList());
   for (subContext.selector = selector.selectorList()->first();
        subContext.selector;
        subContext.selector = subContext.selector->tagHistory()) {
     // :not cannot nest. I don't really know why this is a
     // restriction in CSS3, but it is, so let's honor it.
     // the parser enforces that this never occurs
-    ASSERT(subContext.selector->getPseudoType() != CSSSelector::PseudoNot);
-    // We select between :visited and :link when applying. We don't know which one applied (or not) yet.
+    DCHECK_NE(subContext.selector->getPseudoType(), CSSSelector::PseudoNot);
+    // We select between :visited and :link when applying. We don't know which
+    // one applied (or not) yet.
     if (subContext.selector->getPseudoType() == CSSSelector::PseudoVisited ||
         (subContext.selector->getPseudoType() == CSSSelector::PseudoLink &&
          subContext.visitedMatchType == VisitedMatchEnabled))
       return true;
     if (m_mode == SharingRules) {
       // context.scope is not available if m_mode == SharingRules.
-      // We cannot determine whether :host or :scope matches a given element or not.
+      // We cannot determine whether :host or :scope matches a given element or
+      // not.
       if (subContext.selector->isHostPseudoClass() ||
           subContext.selector->getPseudoType() == CSSSelector::PseudoScope)
         return true;
       // :hover, :active, :focus, :-webkit-drag relies on setting flags on
       // ComputedStyle even if the whole selector may not match. That
       // means we cannot share style between elements which may fail
       // matching the same selector for different reasons. An example is
       // [attr]:hover which both fail for :hover, but an element without
       // attr won't reach the :hover selector, hence not setting the bit.
       if (subContext.selector->isUserActionPseudoClass())
         return true;
     }
     if (!checkOne(subContext, result))
       return true;
   }
   return false;
 }
 
 bool SelectorChecker::checkPseudoClass(const SelectorCheckingContext& context,
                                        MatchResult& result) const {
   Element& element = *context.element;
   const CSSSelector& selector = *context.selector;
 
   if (context.hasScrollbarPseudo) {
-    // CSS scrollbars match a specific subset of pseudo classes, and they have specialized rules for each
+    // CSS scrollbars match a specific subset of pseudo classes, and they have
+    // specialized rules for each
     // (since there are no elements involved).
     return checkScrollbarPseudoClass(context, result);
   }
 
   switch (selector.getPseudoType()) {
     case CSSSelector::PseudoNot:
       return checkPseudoNot(context, result);
     case CSSSelector::PseudoEmpty: {
       bool result = true;
       for (Node* n = element.firstChild(); n; n = n->nextSibling()) {
@@ skipping 116 matching lines @@
         if (!parent->isFinishedParsingChildren())
           return false;
         return selector.matchNth(NthIndexCache::nthLastOfTypeIndex(element));
       }
       break;
     case CSSSelector::PseudoTarget:
       return element == element.document().cssTarget();
     case CSSSelector::PseudoAny: {
       SelectorCheckingContext subContext(context);
       subContext.isSubSelector = true;
-      ASSERT(selector.selectorList());
+      DCHECK(selector.selectorList());
       for (subContext.selector = selector.selectorList()->first();
            subContext.selector;
            subContext.selector = CSSSelectorList::next(*subContext.selector)) {
         if (match(subContext))
           return true;
       }
     } break;
     case CSSSelector::PseudoAutofill:
       return element.isFormControlElement() &&
              toHTMLFormControlElement(element).isAutofilled();
@@ skipping 116 matching lines @@
       const AtomicString& argument = selector.argument();
       if (value.isEmpty() ||
           !value.startsWith(argument, TextCaseASCIIInsensitive))
         break;
       if (value.length() != argument.length() &&
           value[argument.length()] != '-')
         break;
       return true;
     }
     case CSSSelector::PseudoFullScreen:
-      // While a Document is in the fullscreen state, and the document's current fullscreen
-      // element is an element in the document, the 'full-screen' pseudoclass applies to
-      // that element. Also, an <iframe>, <object> or <embed> element whose child browsing
-      // context's Document is in the fullscreen state has the 'full-screen' pseudoclass applied.
+      // While a Document is in the fullscreen state, and the document's current
+      // fullscreen element is an element in the document, the 'full-screen'
+      // pseudoclass applies to that element. Also, an <iframe>, <object> or
+      // <embed> element whose child browsing context's Document is in the
+      // fullscreen state has the 'full-screen' pseudoclass applied.
       if (isHTMLFrameElementBase(element) &&
           element.containsFullScreenElement())
         return true;
       return Fullscreen::isCurrentFullScreenElement(element);
     case CSSSelector::PseudoFullScreenAncestor:
       return element.containsFullScreenElement();
     case CSSSelector::PseudoInRange:
       if (m_mode == ResolvingStyle)
         element.document().setContainsValidityStyleRules();
       return element.isInRange();
@@ skipping 43 matching lines @@
     case CSSSelector::PseudoIncrement:
     case CSSSelector::PseudoStart:
     case CSSSelector::PseudoEnd:
     case CSSSelector::PseudoDoubleButton:
     case CSSSelector::PseudoSingleButton:
     case CSSSelector::PseudoNoButton:
     case CSSSelector::PseudoCornerPresent:
       return false;
     case CSSSelector::PseudoUnknown:
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
   }
   return false;
 }
 
 bool SelectorChecker::checkPseudoElement(const SelectorCheckingContext& context,
                                          MatchResult& result) const {
   const CSSSelector& selector = *context.selector;
   Element& element = *context.element;
 
@@ skipping 25 matching lines @@
         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()));
+      DCHECK(selector.selectorList()->first());
+      DCHECK(!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:
       if (m_mode == SharingRules)
         return true;
-      ASSERT(m_mode != QueryingRules);
+      DCHECK_NE(m_mode, QueryingRules);
       result.dynamicPseudo = CSSSelector::pseudoId(selector.getPseudoType());
-      ASSERT(result.dynamicPseudo != PseudoIdNone);
+      DCHECK_NE(result.dynamicPseudo, PseudoIdNone);
       return true;
   }
 }
 
 bool SelectorChecker::checkPseudoHost(const SelectorCheckingContext& context,
                                       MatchResult& result) const {
   const CSSSelector& selector = *context.selector;
   Element& element = *context.element;
 
   if (m_mode == SharingRules)
     return true;
-  // :host only matches a shadow host when :host is in a shadow tree of the shadow host.
+  // :host only matches a shadow host when :host is in a shadow tree of the
+  // shadow host.
   if (!context.scope)
     return false;
   const ContainerNode* shadowHost = context.scope->ownerShadowHost();
   if (!shadowHost || shadowHost != element)
     return false;
-  ASSERT(element.shadow());
+  DCHECK(element.shadow());
 
   // For the case with no parameters, i.e. just :host.
   if (!selector.selectorList())
     return true;
 
   SelectorCheckingContext subContext(context);
   subContext.isSubSelector = true;
 
   bool matched = false;
   unsigned maxSpecificity = 0;
 
-  // If one of simple selectors matches an element, returns SelectorMatches. Just "OR".
+  // If one of simple selectors matches an element, returns SelectorMatches.
+  // Just "OR".
   for (subContext.selector = selector.selectorList()->first();
        subContext.selector;
        subContext.selector = CSSSelectorList::next(*subContext.selector)) {
     subContext.treatShadowHostAsNormalScope = true;
     subContext.scope = context.scope;
-    // Use FlatTreeTraversal to traverse a composed ancestor list of a given element.
+    // Use FlatTreeTraversal to traverse a composed ancestor list of a given
+    // element.
     Element* nextElement = &element;
     SelectorCheckingContext hostContext(subContext);
     do {
       MatchResult subResult;
       hostContext.element = nextElement;
       if (match(hostContext, subResult)) {
         matched = true;
         // Consider div:host(div:host(div:host(div:host...))).
         maxSpecificity =
             std::max(maxSpecificity, hostContext.selector->specificity() +
@@ skipping 20 matching lines @@
 }
 
 bool SelectorChecker::checkScrollbarPseudoClass(
     const SelectorCheckingContext& context,
     MatchResult& result) const {
   const CSSSelector& selector = *context.selector;
 
   if (selector.getPseudoType() == CSSSelector::PseudoNot)
     return checkPseudoNot(context, result);
 
-  // FIXME: This is a temporary hack for resizers and scrollbar corners. Eventually :window-inactive should become a real
+  // FIXME: This is a temporary hack for resizers and scrollbar corners.
+  // Eventually :window-inactive should become a real
   // pseudo class and just apply to everything.
   if (selector.getPseudoType() == CSSSelector::PseudoWindowInactive)
     return !context.element->document().page()->focusController().isActive();
 
   if (!m_scrollbar)
     return false;
 
   switch (selector.getPseudoType()) {
     case CSSSelector::PseudoEnabled:
       return m_scrollbar->enabled();
@@ skipping 82 matching lines @@
 }
 
 bool SelectorChecker::matchesFocusPseudoClass(const Element& element) {
   if (InspectorInstrumentation::forcePseudoState(const_cast<Element*>(&element),
                                                  CSSSelector::PseudoFocus))
     return true;
   return element.isFocused() && isFrameFocused(element);
 }
 
 }  // namespace blink