reflow comments in core/style

third_party/WebKit/Source/core/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
+ * rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 119 matching lines @@
 // bit fields, while large fields are stored in pointers and shared where not
 // modified from their parent value (see the DataRef class).
 //
 // Currently, ComputedStyle is hand-written and ComputedStyleBase is generated.
 // Over time, methods will be moved to ComputedStyleBase and the generator will
 // be expanded to handle more and more types of properties. Eventually, all
 // methods will be on ComputedStyleBase (with custom methods defined in a class
 // such as ComputedStyleBase.cpp) and ComputedStyle will be removed.
 class CORE_EXPORT ComputedStyle : public ComputedStyleBase,
                                   public RefCounted<ComputedStyle> {
-  friend class
-      AnimatedStyleBuilder;  // Used by Web Animations CSS. Sets the color styles
-  friend class
-      CSSAnimatableValueFactory;  // Used by Web Animations CSS. Gets visited and unvisited colors separately.
-  friend class
-      CSSPropertyEquality;         // Used by CSS animations. We can't allow them to animate based off visited colors.
-  friend class ApplyStyleCommand;  // Editing has to only reveal unvisited info.
-  friend class EditingStyle;       // Editing has to only reveal unvisited info.
-  friend class
-      ComputedStyleCSSValueMapping;  // Needs to be able to see visited and unvisited colors for devtools.
-  friend class StyleBuilderFunctions;  // Sets color styles
-  friend class
-      CachedUAStyle;  // Saves Border/Background information for later comparison.
-  friend class
-      ColorPropertyFunctions;  // Accesses visited and unvisited colors.
+  // Used by Web Animations CSS. Sets the color styles.
+  friend class AnimatedStyleBuilder;
+  // Used by Web Animations CSS. Gets visited and unvisited colors separately.
+  friend class CSSAnimatableValueFactory;
+  // Used by CSS animations. We can't allow them to animate based off visited
+  // colors.
+  friend class CSSPropertyEquality;
+  // Editing has to only reveal unvisited info.
+  friend class ApplyStyleCommand;
+  // Editing has to only reveal unvisited info.
+  friend class EditingStyle;
+  // Needs to be able to see visited and unvisited colors for devtools.
+  friend class ComputedStyleCSSValueMapping;
+  // Sets color styles
+  friend class StyleBuilderFunctions;
+  // Saves Border/Background information for later comparison.
+  friend class CachedUAStyle;
+  // Accesses visited and unvisited colors.
+  friend class ColorPropertyFunctions;
 
-  // FIXME: When we stop resolving currentColor at style time, these can be removed.
+  // FIXME: When we stop resolving currentColor at style time, these can be
+  // removed.
   friend class CSSToStyleMap;
   friend class FilterOperationResolver;
   friend class StyleBuilderConverter;
   friend class StyleResolverState;
   friend class StyleResolver;
 
  protected:
   // non-inherited attributes
   DataRef<StyleBoxData> m_box;
   DataRef<StyleVisualData> m_visual;
   DataRef<StyleBackgroundData> m_background;
   DataRef<StyleSurroundData> m_surround;
   DataRef<StyleRareNonInheritedData> m_rareNonInheritedData;
 
   // inherited attributes
   DataRef<StyleRareInheritedData> m_rareInheritedData;
   DataRef<StyleInheritedData> m_styleInheritedData;
 
   // list of associated pseudo styles
   std::unique_ptr<PseudoStyleCache> m_cachedPseudoStyles;
 
   DataRef<SVGComputedStyle> m_svgStyle;
 
-  // !START SYNC!: Keep this in sync with the copy constructor in ComputedStyle.cpp and implicitlyInherited() in StyleResolver.cpp
+  // !START SYNC!: Keep this in sync with the copy constructor in
+  // ComputedStyle.cpp and implicitlyInherited() in StyleResolver.cpp
 
   // inherit
   struct InheritedData {
     bool operator==(const InheritedData& other) const {
       return compareEqualIndependent(other) &&
              compareEqualNonIndependent(other);
     }
 
     bool operator!=(const InheritedData& other) const {
       return !(*this == other);
@@ skipping 29 matching lines @@
     unsigned m_captionSide : 2;        // ECaptionSide
     unsigned m_listStyleType : 7;      // EListStyleType
     unsigned m_listStylePosition : 1;  // EListStylePosition
     unsigned m_textAlign : 4;          // ETextAlign
     unsigned m_textTransform : 2;      // ETextTransform
     unsigned m_textUnderline : 1;
     unsigned m_cursorStyle : 6;     // ECursor
     unsigned m_direction : 1;       // TextDirection
     unsigned m_whiteSpace : 3;      // EWhiteSpace
     unsigned m_borderCollapse : 1;  // EBorderCollapse
-    unsigned
-        m_boxDirection : 1;  // EBoxDirection (CSS3 box_direction property, flexible box layout module)
+    unsigned m_boxDirection : 1;  // EBoxDirection (CSS3 box_direction property,
+                                  // flexible box layout module)
     // 32 bits
 
     // non CSS2 inherited
     unsigned m_rtlOrdering : 1;  // Order
     unsigned m_printColorAdjust : PrintColorAdjustBits;
     unsigned m_pointerEvents : 4;  // EPointerEvents
     unsigned m_insideLink : 2;     // EInsideLink
 
     // CSS Text Layout Module Level 3: Vertical writing support
     unsigned m_writingMode : 2;  // WritingMode
@@ skipping 40 matching lines @@
     unsigned m_overflowAnchor : 2;    // EOverflowAnchor
     unsigned m_overflowX : 3;         // EOverflow
     unsigned m_overflowY : 3;         // EOverflow
     unsigned m_verticalAlign : 4;     // EVerticalAlign
     unsigned m_clear : 2;             // EClear
     unsigned m_position : 3;          // EPosition
     unsigned m_tableLayout : 1;       // ETableLayout
     unsigned m_unicodeBidi : 3;       // EUnicodeBidi
 
     // This is set if we used viewport units when resolving a length.
-    // It is mutable so we can pass around const ComputedStyles to resolve lengths.
+    // It is mutable so we can pass around const ComputedStyles to resolve
+    // lengths.
     mutable unsigned m_hasViewportUnits : 1;
 
     // 32 bits
 
     unsigned m_breakBefore : 4;  // EBreak
     unsigned m_breakAfter : 4;   // EBreak
     unsigned m_breakInside : 2;  // EBreak
 
     unsigned m_styleType : 6;  // PseudoId
     unsigned m_pseudoBits : 8;
-    unsigned
-        m_explicitInheritance : 1;  // Explicitly inherits a non-inherited property
-    unsigned
-        m_variableReference : 1;  // A non-inherited property references a variable or @apply is used.
-    unsigned m_unique : 1;  // Style can not be shared.
+    unsigned m_explicitInheritance : 1;  // Explicitly inherits a non-inherited
+                                         // property
+    unsigned m_variableReference : 1;  // A non-inherited property references a
+                                       // variable or @apply is used.
+    unsigned m_unique : 1;             // Style can not be shared.
 
     unsigned m_emptyState : 1;
 
     unsigned m_affectedByFocus : 1;
     unsigned m_affectedByHover : 1;
     unsigned m_affectedByActive : 1;
     unsigned m_affectedByDrag : 1;
 
     // 64 bits
 
     unsigned m_isLink : 1;
 
     mutable unsigned m_hasRemUnits : 1;
 
     // For each independent inherited property, store a 1 if the stored
     // value was inherited from its parent, or 0 if it is explicitly set on
     // this element.
     // Eventually, all properties will have a bit in here to store whether
     // they were inherited from their parent or not.
     // Although two ComputedStyles are equal if their nonInheritedData is
     // equal regardless of the isInherited flags, this struct is stored next
     // to the existing flags to take advantage of packing as much as possible.
     // TODO(sashab): Move these flags closer to inheritedData so that it's
     // clear which inherited properties have a flag stored and which don't.
     // Keep this list of fields in sync with:
     // - setBitDefaults()
-    // - The ComputedStyle setter, which must take an extra boolean parameter and set this
-    // - propagateIndependentInheritedProperties() in ComputedStyle.cpp
+    // - The ComputedStyle setter, which must take an extra boolean parameter
+    //   and set this - propagateIndependentInheritedProperties() in
+    //   ComputedStyle.cpp
     // - The compareEqual() methods in the corresponding class
     // InheritedFlags
     unsigned m_isPointerEventsInherited : 1;
     unsigned m_isVisibilityInherited : 1;
 
-    // If you add more style bits here, you will also need to update ComputedStyle::copyNonInheritedFromCached()
-    // 68 bits
+    // If you add more style bits here, you will also need to update
+    // ComputedStyle::copyNonInheritedFromCached() 68 bits
   } m_nonInheritedData;
 
   // !END SYNC!
 
   void setBitDefaults() {
     ComputedStyleBase::setBitDefaults();
     m_inheritedData.m_emptyCells = static_cast<unsigned>(initialEmptyCells());
     m_inheritedData.m_captionSide = static_cast<unsigned>(initialCaptionSide());
     m_inheritedData.m_listStyleType = initialListStyleType();
     m_inheritedData.m_listStylePosition = initialListStylePosition();
@@ skipping 484 matching lines @@
   // break-after (shorthand for page-break-after and -webkit-column-break-after)
   static EBreak initialBreakAfter() { return BreakAuto; }
   EBreak breakAfter() const {
     return static_cast<EBreak>(m_nonInheritedData.m_breakAfter);
   }
   void setBreakAfter(EBreak b) {
     DCHECK_LE(b, BreakValueLastAllowedForBreakAfterAndBefore);
     m_nonInheritedData.m_breakAfter = b;
   }
 
-  // break-before (shorthand for page-break-before and -webkit-column-break-before)
+  // break-before (shorthand for page-break-before and
+  // -webkit-column-break-before)
   static EBreak initialBreakBefore() { return BreakAuto; }
   EBreak breakBefore() const {
     return static_cast<EBreak>(m_nonInheritedData.m_breakBefore);
   }
   void setBreakBefore(EBreak b) {
     DCHECK_LE(b, BreakValueLastAllowedForBreakAfterAndBefore);
     m_nonInheritedData.m_breakBefore = b;
   }
 
-  // break-inside (shorthand for page-break-inside and -webkit-column-break-inside)
+  // break-inside (shorthand for page-break-inside and
+  // -webkit-column-break-inside)
   static EBreak initialBreakInside() { return BreakAuto; }
   EBreak breakInside() const {
     return static_cast<EBreak>(m_nonInheritedData.m_breakInside);
   }
   void setBreakInside(EBreak b) {
     DCHECK_LE(b, BreakValueLastAllowedForBreakInside);
     m_nonInheritedData.m_breakInside = b;
   }
 
   // clip
@@ skipping 193 matching lines @@
   static unsigned initialBoxFlexGroup() { return 1; }
   unsigned boxFlexGroup() const {
     return m_rareNonInheritedData->m_deprecatedFlexibleBox->flexGroup;
   }
   void setBoxFlexGroup(unsigned fg) {
     SET_NESTED_VAR(m_rareNonInheritedData, m_deprecatedFlexibleBox, flexGroup,
                    fg);
   }
 
   // -webkit-box-align
-  // For valid values of box-align see http://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment
+  // For valid values of box-align see
+  // http://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment
   static EBoxAlignment initialBoxAlign() { return BSTRETCH; }
   EBoxAlignment boxAlign() const {
     return static_cast<EBoxAlignment>(
         m_rareNonInheritedData->m_deprecatedFlexibleBox->align);
   }
   void setBoxAlign(EBoxAlignment a) {
     SET_NESTED_VAR(m_rareNonInheritedData, m_deprecatedFlexibleBox, align, a);
   }
 
   // -webkit-box-decoration-break
@@ skipping 385 matching lines @@
   static float initialOpacity() { return 1.0f; }
   float opacity() const { return m_rareNonInheritedData->opacity; }
   void setOpacity(float f) {
     float v = clampTo<float>(f, 0, 1);
     SET_VAR(m_rareNonInheritedData, opacity, v);
   }
 
   // order (aka -webkit-order)
   static int initialOrder() { return 0; }
   int order() const { return m_rareNonInheritedData->m_order; }
-  // We restrict the smallest value to int min + 2 because we use int min and int min + 1 as special values in a hash set.
+  // We restrict the smallest value to int min + 2 because we use int min and
+  // int min + 1 as special values in a hash set.
   void setOrder(int o) {
     SET_VAR(m_rareNonInheritedData, m_order,
             max(std::numeric_limits<int>::min() + 2, o));
   }
 
   // Outline properties.
   // outline-color
   void setOutlineColor(const StyleColor& v) {
     SET_BORDERVALUE_COLOR(m_background, m_outline, v);
   }
@@ skipping 1012 matching lines @@
   FontWeight fontWeight() const;
 
   // font-stretch
   FontStretch fontStretch() const;
 
   // -webkit-locale
   const AtomicString& locale() const {
     return LayoutLocale::localeString(getFontDescription().locale());
   }
 
-  // FIXME: Remove letter-spacing/word-spacing and replace them with respective FontBuilder calls.
-  // letter-spacing
+  // FIXME: Remove letter-spacing/word-spacing and replace them with respective
+  // FontBuilder calls.  letter-spacing
   static float initialLetterWordSpacing() { return 0.0f; }
   float letterSpacing() const;
   void setLetterSpacing(float);
 
   // word-spacing
   float wordSpacing() const;
   void setWordSpacing(float);
 
   // SVG properties.
   const SVGComputedStyle& svgStyle() const { return *m_svgStyle.get(); }
@@ skipping 254 matching lines @@
     SET_VAR(m_rareNonInheritedData, m_hasAuthorBackground, authorBackground);
   }
 
   bool hasAuthorBorder() const {
     return m_rareNonInheritedData->m_hasAuthorBorder;
   };
   void setHasAuthorBorder(bool authorBorder) {
     SET_VAR(m_rareNonInheritedData, m_hasAuthorBorder, authorBorder);
   }
 
-  // A stacking context is painted atomically and defines a stacking order, whereas
-  // a containing stacking context defines in which order the stacking contexts
-  // below are painted.
-  // See CSS 2.1, Appendix E (https://www.w3.org/TR/CSS21/zindex.html) for more details.
+  // A stacking context is painted atomically and defines a stacking order,
+  // whereas a containing stacking context defines in which order the stacking
+  // contexts below are painted.
+  // See CSS 2.1, Appendix E (https://www.w3.org/TR/CSS21/zindex.html) for more
+  // details.
   bool isStackingContext() const {
     return m_rareNonInheritedData->m_isStackingContext;
   }
   void setIsStackingContext(bool b) {
     SET_VAR(m_rareNonInheritedData, m_isStackingContext, b);
   }
 
-  // A unique style is one that has matches something that makes it impossible to share.
+  // A unique style is one that has matches something that makes it impossible
+  // to share.
   bool unique() const { return m_nonInheritedData.m_unique; }
   void setUnique() { m_nonInheritedData.m_unique = true; }
 
   float textAutosizingMultiplier() const {
     return m_styleInheritedData->textAutosizingMultiplier;
   }
   void setTextAutosizingMultiplier(float);
 
   bool selfOrAncestorHasDirAutoAttribute() const {
     return m_rareInheritedData->m_selfOrAncestorHasDirAutoAttribute;
@@ skipping 620 matching lines @@
   void resetPageSizeType() {
     SET_VAR(m_rareNonInheritedData, m_pageSizeType, PAGE_SIZE_AUTO);
   }
 
   // Outline utility functions.
   bool hasOutline() const {
     return outlineWidth() > 0 && outlineStyle() > BorderStyleHidden;
   }
   int outlineOutsetExtent() const;
   bool isOutlineEquivalent(const ComputedStyle* otherStyle) const {
-    // No other style, so we don't have an outline then we consider them to be the same.
+    // No other style, so we don't have an outline then we consider them to be
+    // the same.
     if (!otherStyle)
       return !hasOutline();
     return m_background->outline().visuallyEqual(
         otherStyle->m_background->outline());
   }
   void setOutlineFromStyle(const ComputedStyle& o) {
     DCHECK(!isOutlineEquivalent(&o));
     m_background.access()->m_outline = o.m_background->m_outline;
   }
 
@@ skipping 101 matching lines @@
 
   // Overflow utility functions.
 
   EOverflow overflowInlineDirection() const {
     return isHorizontalWritingMode() ? overflowX() : overflowY();
   }
   EOverflow overflowBlockDirection() const {
     return isHorizontalWritingMode() ? overflowY() : overflowX();
   }
 
-  // It's sufficient to just check one direction, since it's illegal to have visible on only one overflow value.
+  // It's sufficient to just check one direction, since it's illegal to have
+  // visible on only one overflow value.
   bool isOverflowVisible() const {
     DCHECK(overflowX() != OverflowVisible || overflowX() == overflowY());
     return overflowX() == OverflowVisible;
   }
   bool isOverflowPaged() const {
     return overflowY() == OverflowPagedX || overflowY() == OverflowPagedY;
   }
 
   // Animation utility functions.
   bool shouldCompositeForCurrentAnimations() const {
@@ skipping 53 matching lines @@
                       ApplyTransformOrigin,
                       ApplyMotionPath,
                       ApplyIndependentTransformProperties) const;
 
   // Returns |true| if any property that renders using filter operations is
   // used (including, but not limited to, 'filter' and 'box-reflect').
   bool hasFilterInducingProperty() const {
     return hasFilter() || hasBoxReflect();
   }
 
-  // Returns |true| if opacity should be considered to have non-initial value for the purpose
-  // of creating stacking contexts.
+  // Returns |true| if opacity should be considered to have non-initial value
+  // for the purpose of creating stacking contexts.
   bool hasNonInitialOpacity() const {
     return hasOpacity() || hasWillChangeOpacityHint() ||
            hasCurrentOpacityAnimation();
   }
 
-  // Returns whether this style contains any grouping property as defined by [css-transforms].
-  // The main purpose of this is to adjust the used value of transform-style property.
-  // Note: We currently don't include every grouping property on the spec to maintain
-  //       backward compatibility.
-  // [css-transforms] https://drafts.csswg.org/css-transforms/#grouping-property-values
+  // Returns whether this style contains any grouping property as defined by
+  // [css-transforms].  The main purpose of this is to adjust the used value of
+  // transform-style property.
+  // Note: We currently don't include every grouping property on the spec to
+  // maintain backward compatibility.  [css-transforms]
+  // https://drafts.csswg.org/css-transforms/#grouping-property-values
   bool hasGroupingProperty() const {
     return !isOverflowVisible() || hasFilterInducingProperty() ||
            hasNonInitialOpacity();
   }
 
-  // Return true if any transform related property (currently transform/motionPath, transformStyle3D, perspective,
-  // or will-change:transform) indicates that we are transforming. will-change:transform should result in
-  // the same rendering behavior as having a transform, including the creation of a containing block
-  // for fixed position descendants.
+  // Return true if any transform related property (currently
+  // transform/motionPath, transformStyle3D, perspective, or
+  // will-change:transform) indicates that we are transforming.
+  // will-change:transform should result in the same rendering behavior as
+  // having a transform, including the creation of a containing block for fixed
+  // position descendants.
   bool hasTransformRelatedProperty() const {
     return hasTransform() || preserves3D() || hasPerspective() ||
            hasWillChangeTransformHint();
   }
 
   // Paint utility functions.
   void addPaintImage(StyleImage*);
 
-  // FIXME: reflections should belong to this helper function but they are currently handled
-  // through their self-painting layers. So the layout code doesn't account for them.
+  // FIXME: reflections should belong to this helper function but they are
+  // currently handled through their self-painting layers. So the layout code
+  // doesn't account for them.
   bool hasVisualOverflowingEffect() const {
     return boxShadow() || hasBorderImageOutsets() || hasOutline();
   }
 
-  // Stacking contexts and positioned elements[1] are stacked (sorted in negZOrderList
+  // Stacking contexts and positioned elements[1] are stacked (sorted in
+  // negZOrderList
   // and posZOrderList) in their enclosing stacking contexts.
   //
-  // [1] According to CSS2.1, Appendix E.2.8 (https://www.w3.org/TR/CSS21/zindex.html),
-  // positioned elements with 'z-index: auto' are "treated as if it created a new
-  // stacking context" and z-ordered together with other elements with 'z-index: 0'.
-  // The difference of them from normal stacking contexts is that they don't determine
-  // the stacking of the elements underneath them.
-  // (Note: There are also other elements treated as stacking context during painting,
+  // [1] According to CSS2.1, Appendix E.2.8
+  // (https://www.w3.org/TR/CSS21/zindex.html),
+  // positioned elements with 'z-index: auto' are "treated as if it created a
+  // new stacking context" and z-ordered together with other elements with
+  // 'z-index: 0'.  The difference of them from normal stacking contexts is that
+  // they don't determine the stacking of the elements underneath them.  (Note:
+  // There are also other elements treated as stacking context during painting,
   // but not managed in stacks. See ObjectPainter::paintAllPhasesAtomically().)
   void updateIsStackingContext(bool isDocumentElement, bool isInTopLayer);
   bool isStacked() const {
     return isStackingContext() || position() != StaticPosition;
   }
 
   // Pseudo-styles
   bool hasAnyPublicPseudoStyles() const;
   bool hasPseudoStyle(PseudoId) const;
   void setHasPseudoStyle(PseudoId);
   bool hasUniquePseudoStyle() const;
   bool hasPseudoElementStyle() const;
 
-  // Note: canContainAbsolutePositionObjects should return true if canContainFixedPositionObjects.
-  // We currently never use this value directly, always OR'ing it with canContainFixedPositionObjects.
+  // Note: canContainAbsolutePositionObjects should return true if
+  // canContainFixedPositionObjects.  We currently never use this value
+  // directly, always OR'ing it with canContainFixedPositionObjects.
   bool canContainAbsolutePositionObjects() const {
     return position() != StaticPosition;
   }
   bool canContainFixedPositionObjects() const {
     return hasTransformRelatedProperty() || containsPaint();
   }
 
   // Whitespace utility functions.
   static bool autoWrap(EWhiteSpace ws) {
     // Nowrap and pre don't automatically wrap.
@@ skipping 35 matching lines @@
     return (wordBreak() == BreakWordBreak ||
             overflowWrap() == BreakOverflowWrap) &&
            whiteSpace() != PRE && whiteSpace() != NOWRAP;
   }
 
   // Text direction utility functions.
   bool shouldPlaceBlockDirectionScrollbarOnLogicalLeft() const {
     return !isLeftToRightDirection() && isHorizontalWritingMode();
   }
   bool hasInlinePaginationAxis() const {
-    // If the pagination axis is parallel with the writing mode inline axis, columns may be laid
-    // out along the inline axis, just like for regular multicol. Otherwise, we need to lay out
-    // along the block axis.
+    // If the pagination axis is parallel with the writing mode inline axis,
+    // columns may be laid out along the inline axis, just like for regular
+    // multicol. Otherwise, we need to lay out along the block axis.
     if (isOverflowPaged())
       return (overflowY() == OverflowPagedX) == isHorizontalWritingMode();
     return false;
   }
 
   // Border utility functions.
   bool borderObscuresBackground() const;
   void getBorderEdgeInfo(BorderEdge edges[],
                          bool includeLogicalLeftEdge = true,
                          bool includeLogicalRightEdge = true) const;
@@ skipping 34 matching lines @@
     return shadowListHasCurrentColor(boxShadow());
   }
   bool hasBackground() const {
     Color color = visitedDependentColor(CSSPropertyBackgroundColor);
     if (color.alpha())
       return true;
     return hasBackgroundImage();
   }
 
   // Color utility functions.
-  // TODO(sashab): Rename this to just getColor(), and add a comment explaining how it works.
+  // TODO(sashab): Rename this to just getColor(), and add a comment explaining
+  // how it works.
   Color visitedDependentColor(int colorProperty) const;
 
   // -webkit-appearance utility functions.
   bool hasAppearance() const { return appearance() != NoControlPart; }
 
   // Other utility functions.
   bool isStyleAvailable() const;
   bool isSharable() const;
 
  private:
@@ skipping 62 matching lines @@
     return display == EDisplay::Table || display == EDisplay::InlineTable ||
            display == EDisplay::TableRowGroup ||
            display == EDisplay::TableHeaderGroup ||
            display == EDisplay::TableFooterGroup ||
            display == EDisplay::TableRow ||
            display == EDisplay::TableColumnGroup ||
            display == EDisplay::TableColumn || display == EDisplay::TableCell ||
            display == EDisplay::TableCaption;
   }
 
-  // Color accessors are all private to make sure callers use visitedDependentColor instead to access them.
+  // Color accessors are all private to make sure callers use
+  // visitedDependentColor instead to access them.
   StyleColor borderLeftColor() const {
     return m_surround->border.left().color();
   }
   StyleColor borderRightColor() const {
     return m_surround->border.right().color();
   }
   StyleColor borderTopColor() const { return m_surround->border.top().color(); }
   StyleColor borderBottomColor() const {
     return m_surround->border.bottom().color();
   }
@@ skipping 167 matching lines @@
   m_nonInheritedData.m_pseudoBits |= 1 << (pseudo - 1);
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const {
   return m_nonInheritedData.m_pseudoBits & ElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h