Reflow comments in core/css

third_party/WebKit/Source/core/css/CSSSelector.h

 /*
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
- * Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
@@ skipping 11 matching lines @@
 #include "core/dom/QualifiedName.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "wtf/RefCounted.h"
 #include <memory>
 
 namespace blink {
 class CSSSelectorList;
 
 // This class represents a selector for a StyleRule.
 
-// CSS selector representation is somewhat complicated and subtle. A representative list of selectors is
-// in CSSSelectorTest; run it in a debug build to see useful debugging output.
+// CSS selector representation is somewhat complicated and subtle. A
+// representative list of selectors is in CSSSelectorTest; run it in a debug
+// build to see useful debugging output.
 //
 // ** tagHistory() and relation():
 //
-// Selectors are represented as a linked list of simple selectors (defined more or less according to
-// http://www.w3.org/TR/css3-selectors/#simple-selectors-dfn). The tagHistory() method returns the next
-// simple selector in the list. The relation() method returns the relationship of the current simple selector to
-// the one in tagHistory(). For example, the CSS selector .a.b #c is represented as:
+// Selectors are represented as a linked list of simple selectors (defined more
+// or less according to
+// http://www.w3.org/TR/css3-selectors/#simple-selectors-dfn). The tagHistory()
+// method returns the next simple selector in the list. The relation() method
+// returns the relationship of the current simple selector to the one in
+// tagHistory(). For example, the CSS selector .a.b #c is represented as:
 //
 // selectorText(): .a.b #c
 // --> (relation == Descendant)
 //   selectorText(): .a.b
 //   --> (relation == SubSelector)
 //     selectorText(): .b
 //
 // The order of tagHistory() varies depending on the situation.
-// * Relations using combinators (http://www.w3.org/TR/css3-selectors/#combinators), such as descendant, sibling, etc., are parsed
-//   right-to-left (in the example above, this is why #c is earlier in the tagHistory() chain than .a.b).
-// * SubSelector relations are parsed left-to-right in most cases (such as the .a.b example above); a counter-example is the
-//   ::content pseudo-element. Most (all?) other pseudo elements and pseudo classes are parsed left-to-right.
-// * ShadowPseudo relations are parsed right-to-left. Example: summary::-webkit-details-marker is parsed as:
-//   selectorText(): summary::-webkit-details-marker
-//    --> (relation == ShadowPseudo)
-//     selectorText(): summary
+// * Relations using combinators
+//   (http://www.w3.org/TR/css3-selectors/#combinators), such as descendant,
+//   sibling, etc., are parsed right-to-left (in the example above, this is why
+//   #c is earlier in the tagHistory() chain than .a.b).
+// * SubSelector relations are parsed left-to-right in most cases (such as the
+//   .a.b example above); a counter-example is the
+//   ::content pseudo-element. Most (all?) other pseudo elements and pseudo
+//   classes are parsed left-to-right.
+// * ShadowPseudo relations are parsed right-to-left. Example:
+//   summary::-webkit-details-marker is parsed as: selectorText():
+//   summary::-webkit-details-marker --> (relation == ShadowPseudo)
+//   selectorText(): summary
 //
 // ** match():
 //
-// The match of the current simple selector tells us the type of selector, such as class, id, tagname, or pseudo-class.
-// Inline comments in the Match enum give examples of when each type would occur.
+// The match of the current simple selector tells us the type of selector, such
+// as class, id, tagname, or pseudo-class. Inline comments in the Match enum
+// give examples of when each type would occur.
 //
 // ** value(), attribute():
 //
-// value() tells you the value of the simple selector. For example, for class selectors, value() will tell you the class string,
-// and for id selectors it will tell you the id(). See below for the special case of attribute selectors.
+// value() tells you the value of the simple selector. For example, for class
+// selectors, value() will tell you the class string, and for id selectors it
+// will tell you the id(). See below for the special case of attribute
+// selectors.
 //
 // ** Attribute selectors.
 //
-// Attribute selectors return the attribute name in the attribute() method. The value() method returns the value matched against
-// in case of selectors like [attr="value"].
+// Attribute selectors return the attribute name in the attribute() method. The
+// value() method returns the value matched against in case of selectors like
+// [attr="value"].
 //
 class CORE_EXPORT CSSSelector {
   USING_FAST_MALLOC_WITH_TYPE_NAME(blink::CSSSelector);
 
  public:
   CSSSelector();
   CSSSelector(const CSSSelector&);
   explicit CSSSelector(const QualifiedName&, bool tagIsImplicit = false);
 
   ~CSSSelector();
@@ skipping 24 matching lines @@
     AttributeEnd,      // css3: E[foo$="bar"]
     FirstAttributeSelectorMatch = AttributeExact,
   };
 
   enum RelationType {
     SubSelector,       // No combinator
     Descendant,        // "Space" combinator
     Child,             // > combinator
     DirectAdjacent,    // + combinator
     IndirectAdjacent,  // ~ combinator
-    ShadowPseudo,  // Special case of shadow DOM pseudo elements / shadow pseudo element
+    // Special case of shadow DOM pseudo elements / shadow pseudo element
+    ShadowPseudo,
     ShadowDeep,  // /deep/ combinator
     ShadowSlot   // slotted to <slot> element
   };
 
   enum PseudoType {
     PseudoUnknown,
     PseudoEmpty,
     PseudoFirstChild,
     PseudoFirstOfType,
     PseudoLastChild,
@@ skipping 88 matching lines @@
 
   PseudoType getPseudoType() const {
     return static_cast<PseudoType>(m_pseudoType);
   }
   void updatePseudoType(const AtomicString&, bool hasArguments);
 
   static PseudoType parsePseudoType(const AtomicString&, bool hasArguments);
   static PseudoId parsePseudoId(const String&);
   static PseudoId pseudoId(PseudoType);
 
-  // Selectors are kept in an array by CSSSelectorList. The next component of the selector is
-  // the next item in the array.
+  // Selectors are kept in an array by CSSSelectorList. The next component of
+  // the selector is the next item in the array.
   const CSSSelector* tagHistory() const {
     return m_isLastInTagHistory ? 0 : const_cast<CSSSelector*>(this + 1);
   }
 
   const QualifiedName& tagQName() const;
   const AtomicString& value() const;
   const AtomicString& serializingValue() const;
 
   // WARNING: Use of QualifiedName by attribute() is a lie.
   // attribute() will return a QualifiedName with prefix and namespaceURI
   // set to starAtom to mean "matches any namespace". Be very careful
   // how you use the returned QualifiedName.
   // http://www.w3.org/TR/css3-selectors/#attrnmsp
   const QualifiedName& attribute() const;
   AttributeMatchType attributeMatch() const;
-  // Returns the argument of a parameterized selector. For example, :lang(en-US) would have an argument of en-US.
-  // Note that :nth-* selectors don't store an argument and just store the numbers.
+  // Returns the argument of a parameterized selector. For example, :lang(en-US)
+  // would have an argument of en-US.
+  // Note that :nth-* selectors don't store an argument and just store the
+  // numbers.
   const AtomicString& argument() const {
     return m_hasRareData ? m_data.m_rareData->m_argument : nullAtom;
   }
   const CSSSelectorList* selectorList() const {
     return m_hasRareData ? m_data.m_rareData->m_selectorList.get() : nullptr;
   }
 
 #ifndef NDEBUG
   void show() const;
   void show(int indent) const;
@@ skipping 260 matching lines @@
 }
 
 inline bool CSSSelector::isIdClassOrAttributeSelector() const {
   return isAttributeSelector() || match() == CSSSelector::Id ||
          match() == CSSSelector::Class;
 }
 
 }  // namespace blink
 
 #endif  // CSSSelector_h