reflow comments in core/style

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

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights
+ * reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. 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
@@ skipping 173 matching lines @@
         oldStyle.getCachedPseudoStyle(pseudoId);
     if (oldPseudoStyle && *oldPseudoStyle != *newPseudoStyle)
       return NoInherit;
   }
   return NoChange;
 }
 
 StyleRecalcChange ComputedStyle::stylePropagationDiff(
     const ComputedStyle* oldStyle,
     const ComputedStyle* newStyle) {
-  // If the style has changed from display none or to display none, then the layout subtree needs to be reattached
+  // If the style has changed from display none or to display none, then the
+  // layout subtree needs to be reattached
   if ((!oldStyle && newStyle) || (oldStyle && !newStyle))
     return Reattach;
 
   if (!oldStyle && !newStyle)
     return NoChange;
 
   if (oldStyle->display() != newStyle->display() ||
       oldStyle->hasPseudoStyle(PseudoIdFirstLetter) !=
           newStyle->hasPseudoStyle(PseudoIdFirstLetter) ||
       !oldStyle->contentDataEquivalent(newStyle) ||
@@ skipping 27 matching lines @@
     const ComputedStyle& parentStyle) {
   if (m_nonInheritedData.m_isPointerEventsInherited)
     setPointerEvents(parentStyle.pointerEvents());
   if (m_nonInheritedData.m_isVisibilityInherited)
     setVisibility(parentStyle.visibility());
 }
 
 StyleSelfAlignmentData resolvedSelfAlignment(
     const StyleSelfAlignmentData& value,
     ItemPosition normalValueBehavior) {
-  // To avoid needing to copy the RareNonInheritedData, we repurpose the 'auto' flag to not just mean 'auto' prior to running the StyleAdjuster but also mean 'normal' after running it.
+  // To avoid needing to copy the RareNonInheritedData, we repurpose the 'auto'
+  // flag to not just mean 'auto' prior to running the StyleAdjuster but also
+  // mean 'normal' after running it.
   if (value.position() == ItemPositionNormal ||
       value.position() == ItemPositionAuto)
     return {normalValueBehavior, OverflowAlignmentDefault};
   return value;
 }
 
 StyleSelfAlignmentData ComputedStyle::resolvedAlignItems(
     ItemPosition normalValueBehaviour) const {
-  // We will return the behaviour of 'normal' value if needed, which is specific of each layout model.
+  // We will return the behaviour of 'normal' value if needed, which is specific
+  // of each layout model.
   return resolvedSelfAlignment(alignItems(), normalValueBehaviour);
 }
 
 StyleSelfAlignmentData ComputedStyle::resolvedAlignSelf(
     ItemPosition normalValueBehaviour,
     const ComputedStyle* parentStyle) const {
-  // We will return the behaviour of 'normal' value if needed, which is specific of each layout model.
+  // We will return the behaviour of 'normal' value if needed, which is specific
+  // of each layout model.
   if (!parentStyle || alignSelfPosition() != ItemPositionAuto)
     return resolvedSelfAlignment(alignSelf(), normalValueBehaviour);
 
-  // We shouldn't need to resolve any 'auto' value in post-adjusment ComputedStyle, but some layout models
-  // can generate anonymous boxes that may need 'auto' value resolution during layout.
+  // We shouldn't need to resolve any 'auto' value in post-adjusment
+  // ComputedStyle, but some layout models can generate anonymous boxes that may
+  // need 'auto' value resolution during layout.
   // The 'auto' keyword computes to the parent's align-items computed value.
   return parentStyle->resolvedAlignItems(normalValueBehaviour);
 }
 
 StyleSelfAlignmentData ComputedStyle::resolvedJustifyItems(
     ItemPosition normalValueBehaviour) const {
-  // We will return the behaviour of 'normal' value if needed, which is specific of each layout model.
+  // We will return the behaviour of 'normal' value if needed, which is specific
+  // of each layout model.
   return resolvedSelfAlignment(justifyItems(), normalValueBehaviour);
 }
 
 StyleSelfAlignmentData ComputedStyle::resolvedJustifySelf(
     ItemPosition normalValueBehaviour,
     const ComputedStyle* parentStyle) const {
-  // We will return the behaviour of 'normal' value if needed, which is specific of each layout model.
+  // We will return the behaviour of 'normal' value if needed, which is specific
+  // of each layout model.
   if (!parentStyle || justifySelfPosition() != ItemPositionAuto)
     return resolvedSelfAlignment(justifySelf(), normalValueBehaviour);
 
-  // We shouldn't need to resolve any 'auto' value in post-adjusment ComputedStyle, but some layout models
-  // can generate anonymous boxes that may need 'auto' value resolution during layout.
+  // We shouldn't need to resolve any 'auto' value in post-adjusment
+  // ComputedStyle, but some layout models can generate anonymous boxes that may
+  // need 'auto' value resolution during layout.
   // The auto keyword computes to the parent's justify-items computed value.
   return parentStyle->resolvedJustifyItems(normalValueBehaviour);
 }
 
 static inline ContentPosition resolvedContentAlignmentPosition(
     const StyleContentAlignmentData& value,
     const StyleContentAlignmentData& normalValueBehavior) {
   return (value.position() == ContentPositionNormal &&
           value.distribution() == ContentDistributionDefault)
              ? normalValueBehavior.position()
@@ skipping 29 matching lines @@
 ContentDistributionType ComputedStyle::resolvedAlignContentDistribution(
     const StyleContentAlignmentData& normalValueBehavior) const {
   return resolvedContentAlignmentDistribution(alignContent(),
                                               normalValueBehavior);
 }
 
 void ComputedStyle::inheritFrom(const ComputedStyle& inheritParent,
                                 IsAtShadowBoundary isAtShadowBoundary) {
   ComputedStyleBase::inheritFrom(inheritParent, isAtShadowBoundary);
   if (isAtShadowBoundary == AtShadowBoundary) {
-    // Even if surrounding content is user-editable, shadow DOM should act as a single unit, and not necessarily be editable
+    // Even if surrounding content is user-editable, shadow DOM should act as a
+    // single unit, and not necessarily be editable
     EUserModify currentUserModify = userModify();
     m_rareInheritedData = inheritParent.m_rareInheritedData;
     setUserModify(currentUserModify);
   } else {
     m_rareInheritedData = inheritParent.m_rareInheritedData;
   }
   m_styleInheritedData = inheritParent.m_styleInheritedData;
   m_inheritedData = inheritParent.m_inheritedData;
   if (m_svgStyle != inheritParent.m_svgStyle)
     m_svgStyle.access()->inheritFrom(inheritParent.m_svgStyle.get());
 }
 
 void ComputedStyle::copyNonInheritedFromCached(const ComputedStyle& other) {
   ComputedStyleBase::copyNonInheritedFromCached(other);
   m_box = other.m_box;
   m_visual = other.m_visual;
   m_background = other.m_background;
   m_surround = other.m_surround;
   m_rareNonInheritedData = other.m_rareNonInheritedData;
 
-  // The flags are copied one-by-one because m_nonInheritedData.m_contains a bunch of stuff other than real style data.
+  // The flags are copied one-by-one because m_nonInheritedData.m_contains a
+  // bunch of stuff other than real style data.
   // See comments for each skipped flag below.
   m_nonInheritedData.m_effectiveDisplay =
       other.m_nonInheritedData.m_effectiveDisplay;
   m_nonInheritedData.m_originalDisplay =
       other.m_nonInheritedData.m_originalDisplay;
   m_nonInheritedData.m_overflowAnchor =
       other.m_nonInheritedData.m_overflowAnchor;
   m_nonInheritedData.m_overflowX = other.m_nonInheritedData.m_overflowX;
   m_nonInheritedData.m_overflowY = other.m_nonInheritedData.m_overflowY;
   m_nonInheritedData.m_verticalAlign = other.m_nonInheritedData.m_verticalAlign;
@@ skipping 18 matching lines @@
   // unique() styles are not cacheable.
   DCHECK(!other.m_nonInheritedData.m_unique);
 
   // styles with non inherited properties that reference variables are not
   // cacheable.
   DCHECK(!other.m_nonInheritedData.m_variableReference);
 
   // The following flags are set during matching before we decide that we get a
   // match in the MatchedPropertiesCache which in turn calls this method. The
   // reason why we don't copy these flags is that they're already correctly set
-  // and that they may differ between elements which have the same set of matched
-  // properties. For instance, given the rule:
+  // and that they may differ between elements which have the same set of
+  // matched properties. For instance, given the rule:
   //
   // :-webkit-any(:hover, :focus) { background-color: green }"
   //
   // A hovered element, and a focused element may use the same cached matched
   // properties here, but the affectedBy flags will be set differently based on
   // the matching order of the :-webkit-any components.
   //
   // m_nonInheritedData.m_emptyState
   // m_nonInheritedData.m_affectedByFocus
   // m_nonInheritedData.m_affectedByHover
@@ skipping 118 matching lines @@
   // TODO(sashab): Should ComputedStyleBase have an inheritedDataShared method?
   return ComputedStyleBase::inheritedEqual(other) &&
          m_inheritedData == other.m_inheritedData &&
          m_styleInheritedData.get() == other.m_styleInheritedData.get() &&
          m_svgStyle.get() == other.m_svgStyle.get() &&
          m_rareInheritedData.get() == other.m_rareInheritedData.get();
 }
 
 static bool dependenceOnContentHeightHasChanged(const ComputedStyle& a,
                                                 const ComputedStyle& b) {
-  // If top or bottom become auto/non-auto then it means we either have to solve height based
-  // on the content or stop doing so (http://www.w3.org/TR/CSS2/visudet.html#abs-non-replaced-height)
+  // If top or bottom become auto/non-auto then it means we either have to solve
+  // height based on the content or stop doing so
+  // (http://www.w3.org/TR/CSS2/visudet.html#abs-non-replaced-height)
   // - either way requires a layout.
   return a.logicalTop().isAuto() != b.logicalTop().isAuto() ||
          a.logicalBottom().isAuto() != b.logicalBottom().isAuto();
 }
 
 StyleDifference ComputedStyle::visualInvalidationDiff(
     const ComputedStyle& other) const {
-  // Note, we use .get() on each DataRef below because DataRef::operator== will do a deep
-  // compare, which is duplicate work when we're going to compare each property inside
-  // this function anyway.
+  // Note, we use .get() on each DataRef below because DataRef::operator== will
+  // do a deep compare, which is duplicate work when we're going to compare each
+  // property inside this function anyway.
 
   StyleDifference diff;
   if (m_svgStyle.get() != other.m_svgStyle.get())
     diff = m_svgStyle->diff(other.m_svgStyle.get());
 
   if ((!diff.needsFullLayout() || !diff.needsPaintInvalidation()) &&
       diffNeedsFullLayoutAndPaintInvalidation(other)) {
     diff.setNeedsFullLayout();
     diff.setNeedsPaintInvalidationObject();
   }
 
   if (!diff.needsFullLayout() && diffNeedsFullLayout(other))
     diff.setNeedsFullLayout();
 
   if (!diff.needsFullLayout() &&
       m_surround->margin != other.m_surround->margin) {
-    // Relative-positioned elements collapse their margins so need a full layout.
+    // Relative-positioned elements collapse their margins so need a full
+    // layout.
     if (hasOutOfFlowPosition())
       diff.setNeedsPositionedMovementLayout();
     else
       diff.setNeedsFullLayout();
   }
 
   if (!diff.needsFullLayout() && position() != StaticPosition &&
       m_surround->offset != other.m_surround->offset) {
-    // Optimize for the case where a positioned layer is moving but not changing size.
+    // Optimize for the case where a positioned layer is moving but not changing
+    // size.
     if (dependenceOnContentHeightHasChanged(*this, other))
       diff.setNeedsFullLayout();
     else
       diff.setNeedsPositionedMovementLayout();
   }
 
   if (diffNeedsPaintInvalidationSubtree(other))
     diff.setNeedsPaintInvalidationSubtree();
   else if (diffNeedsPaintInvalidationObject(other))
     diff.setNeedsPaintInvalidationObject();
 
   updatePropertySpecificDifferences(other, diff);
 
   // TODO(skobes): Refine the criteria for ScrollAnchor-disabling properties.
   // Some things set needsLayout but shouldn't disable scroll anchoring.
   if (diff.needsLayout() || diff.transformChanged())
     diff.setScrollAnchorDisablingPropertyChanged();
 
-  // Cursors are not checked, since they will be set appropriately in response to mouse events,
-  // so they don't need to cause any paint invalidation or layout.
+  // Cursors are not checked, since they will be set appropriately in response
+  // to mouse events, so they don't need to cause any paint invalidation or
+  // layout.
 
-  // Animations don't need to be checked either. We always set the new style on the layoutObject, so we will get a chance to fire off
-  // the resulting transition properly.
+  // Animations don't need to be checked either. We always set the new style on
+  // the layoutObject, so we will get a chance to fire off the resulting
+  // transition properly.
 
   return diff;
 }
 
 bool ComputedStyle::diffNeedsFullLayoutAndPaintInvalidation(
     const ComputedStyle& other) const {
-  // FIXME: Not all cases in this method need both full layout and paint invalidation.
+  // FIXME: Not all cases in this method need both full layout and paint
+  // invalidation.
   // Should move cases into diffNeedsFullLayout() if
   // - don't need paint invalidation at all;
-  // - or the layoutObject knows how to exactly invalidate paints caused by the layout change
-  //   instead of forced full paint invalidation.
+  // - or the layoutObject knows how to exactly invalidate paints caused by the
+  //   layout change instead of forced full paint invalidation.
 
   if (m_surround.get() != other.m_surround.get()) {
-    // If our border widths change, then we need to layout. Other changes to borders only necessitate a paint invalidation.
+    // If our border widths change, then we need to layout. Other changes to
+    // borders only necessitate a paint invalidation.
     if (borderLeftWidth() != other.borderLeftWidth() ||
         borderTopWidth() != other.borderTopWidth() ||
         borderBottomWidth() != other.borderBottomWidth() ||
         borderRightWidth() != other.borderRightWidth())
       return true;
   }
 
   if (m_rareNonInheritedData.get() != other.m_rareNonInheritedData.get()) {
     if (m_rareNonInheritedData->m_appearance !=
             other.m_rareNonInheritedData->m_appearance ||
@@ skipping 36 matching lines @@
         *m_rareNonInheritedData->m_flexibleBox.get() !=
             *other.m_rareNonInheritedData->m_flexibleBox.get())
       return true;
 
     if (m_rareNonInheritedData->m_multiCol.get() !=
             other.m_rareNonInheritedData->m_multiCol.get() &&
         *m_rareNonInheritedData->m_multiCol.get() !=
             *other.m_rareNonInheritedData->m_multiCol.get())
       return true;
 
-    // If the counter directives change, trigger a relayout to re-calculate counter values and rebuild the counter node tree.
+    // If the counter directives change, trigger a relayout to re-calculate
+    // counter values and rebuild the counter node tree.
     const CounterDirectiveMap* mapA =
         m_rareNonInheritedData->m_counterDirectives.get();
     const CounterDirectiveMap* mapB =
         other.m_rareNonInheritedData->m_counterDirectives.get();
     if (!(mapA == mapB || (mapA && mapB && *mapA == *mapB)))
       return true;
 
-    // We only need do layout for opacity changes if adding or losing opacity could trigger a change
+    // We only need do layout for opacity changes if adding or losing opacity
+    // could trigger a change
     // in us being a stacking context.
     if (isStackingContext() != other.isStackingContext() &&
         m_rareNonInheritedData->hasOpacity() !=
             other.m_rareNonInheritedData->hasOpacity()) {
-      // FIXME: We would like to use SimplifiedLayout here, but we can't quite do that yet.
-      // We need to make sure SimplifiedLayout can operate correctly on LayoutInlines (we will need
-      // to add a selfNeedsSimplifiedLayout bit in order to not get confused and taint every line).
-      // In addition we need to solve the floating object issue when layers come and go. Right now
-      // a full layout is necessary to keep floating object lists sane.
+      // FIXME: We would like to use SimplifiedLayout here, but we can't quite
+      // do that yet.  We need to make sure SimplifiedLayout can operate
+      // correctly on LayoutInlines (we will need to add a
+      // selfNeedsSimplifiedLayout bit in order to not get confused and taint
+      // every line).  In addition we need to solve the floating object issue
+      // when layers come and go. Right now a full layout is necessary to keep
+      // floating object lists sane.
       return true;
     }
   }
 
   if (m_rareInheritedData.get() != other.m_rareInheritedData.get()) {
     if (m_rareInheritedData->highlight !=
             other.m_rareInheritedData->highlight ||
         m_rareInheritedData->indent != other.m_rareInheritedData->indent ||
         m_rareInheritedData->m_textAlignLast !=
             other.m_rareInheritedData->m_textAlignLast ||
@@ skipping 96 matching lines @@
 
   if (isDisplayTableType(display())) {
     if (m_inheritedData.m_borderCollapse !=
             other.m_inheritedData.m_borderCollapse ||
         m_inheritedData.m_emptyCells != other.m_inheritedData.m_emptyCells ||
         m_inheritedData.m_captionSide != other.m_inheritedData.m_captionSide ||
         m_nonInheritedData.m_tableLayout !=
             other.m_nonInheritedData.m_tableLayout)
       return true;
 
-    // In the collapsing border model, 'hidden' suppresses other borders, while 'none'
-    // does not, so these style differences can be width differences.
+    // In the collapsing border model, 'hidden' suppresses other borders, while
+    // 'none' does not, so these style differences can be width differences.
     if (m_inheritedData.m_borderCollapse &&
         ((borderTopStyle() == BorderStyleHidden &&
           other.borderTopStyle() == BorderStyleNone) ||
          (borderTopStyle() == BorderStyleNone &&
           other.borderTopStyle() == BorderStyleHidden) ||
          (borderBottomStyle() == BorderStyleHidden &&
           other.borderBottomStyle() == BorderStyleNone) ||
          (borderBottomStyle() == BorderStyleNone &&
           other.borderBottomStyle() == BorderStyleHidden) ||
          (borderLeftStyle() == BorderStyleHidden &&
@@ skipping 14 matching lines @@
   }
 
   if ((visibility() == EVisibility::Collapse) !=
       (other.visibility() == EVisibility::Collapse))
     return true;
 
   if (hasPseudoStyle(PseudoIdScrollbar) !=
       other.hasPseudoStyle(PseudoIdScrollbar))
     return true;
 
-  // Movement of non-static-positioned object is special cased in ComputedStyle::visualInvalidationDiff().
+  // Movement of non-static-positioned object is special cased in
+  // ComputedStyle::visualInvalidationDiff().
 
   return false;
 }
 
 bool ComputedStyle::diffNeedsFullLayout(const ComputedStyle& other) const {
   if (m_box.get() != other.m_box.get()) {
     if (m_box->width() != other.m_box->width() ||
         m_box->minWidth() != other.m_box->minWidth() ||
         m_box->maxWidth() != other.m_box->maxWidth() ||
         m_box->height() != other.m_box->height() ||
@@ skipping 362 matching lines @@
   return false;
 }
 
 bool ComputedStyle::requireTransformOrigin(
     ApplyTransformOrigin applyOrigin,
     ApplyMotionPath applyMotionPath) const {
   const Vector<RefPtr<TransformOperation>>& transformOperations =
       transform().operations();
 
   // transform-origin brackets the transform with translate operations.
-  // Optimize for the case where the only transform is a translation, since the transform-origin is irrelevant
-  // in that case.
+  // Optimize for the case where the only transform is a translation, since the
+  // transform-origin is irrelevant in that case.
   if (applyOrigin != IncludeTransformOrigin)
     return false;
 
   if (applyMotionPath == IncludeMotionPath)
     return true;
 
   unsigned size = transformOperations.size();
   for (unsigned i = 0; i < size; ++i) {
     TransformOperation::OperationType type = transformOperations[i]->type();
     if (type != TransformOperation::TranslateX &&
@@ skipping 72 matching lines @@
     result.translate3d(-originX, -originY, -originZ);
   }
 }
 
 void ComputedStyle::applyMotionPathTransform(
     float originX,
     float originY,
     TransformationMatrix& transform) const {
   const StyleMotionData& motionData =
       m_rareNonInheritedData->m_transform->m_motion;
-  // TODO(ericwilligers): crbug.com/638055 Apply offset-position and offset-anchor.
+  // TODO(ericwilligers): crbug.com/638055 Apply offset-position and
+  // offset-anchor.
   if (!motionData.m_path) {
     return;
   }
   const StylePath& motionPath = *motionData.m_path;
   float pathLength = motionPath.length();
   float distance = floatValueForLength(motionData.m_distance, pathLength);
   float computedDistance;
   if (motionPath.isClosed() && pathLength > 0) {
     computedDistance = fmod(distance, pathLength);
     if (computedDistance < 0)
@@ skipping 667 matching lines @@
       result = decorationColorIncludingFallback(visitedLink);
       break;
     default:
       ASSERT_NOT_REACHED();
       break;
   }
 
   if (!result.isCurrentColor())
     return result.getColor();
 
-  // FIXME: Treating styled borders with initial color differently causes problems
-  // See crbug.com/316559, crbug.com/276231
+  // FIXME: Treating styled borders with initial color differently causes
+  // problems, see crbug.com/316559, crbug.com/276231
   if (!visitedLink &&
       (borderStyle == BorderStyleInset || borderStyle == BorderStyleOutset ||
        borderStyle == BorderStyleRidge || borderStyle == BorderStyleGroove))
     return Color(238, 238, 238);
   return visitedLink ? visitedLinkColor() : color();
 }
 
 Color ComputedStyle::visitedDependentColor(int colorProperty) const {
   Color unvisitedColor = colorIncludingFallback(colorProperty, false);
   if (insideLink() != InsideVisitedLink)
     return unvisitedColor;
 
   Color visitedColor = colorIncludingFallback(colorProperty, true);
 
-  // FIXME: Technically someone could explicitly specify the color transparent, but for now we'll just
-  // assume that if the background color is transparent that it wasn't set. Note that it's weird that
-  // we're returning unvisited info for a visited link, but given our restriction that the alpha values
-  // have to match, it makes more sense to return the unvisited background color if specified than it
-  // does to return black. This behavior matches what Firefox 4 does as well.
+  // FIXME: Technically someone could explicitly specify the color transparent,
+  // but for now we'll just assume that if the background color is transparent
+  // that it wasn't set. Note that it's weird that we're returning unvisited
+  // info for a visited link, but given our restriction that the alpha values
+  // have to match, it makes more sense to return the unvisited background color
+  // if specified than it does to return black. This behavior matches what
+  // Firefox 4 does as well.
   if (colorProperty == CSSPropertyBackgroundColor &&
       visitedColor == Color::transparent)
     return unvisitedColor;
 
-  // Take the alpha from the unvisited color, but get the RGB values from the visited color.
+  // Take the alpha from the unvisited color, but get the RGB values from the
+  // visited color.
   return Color(visitedColor.red(), visitedColor.green(), visitedColor.blue(),
                unvisitedColor.alpha());
 }
 
 const BorderValue& ComputedStyle::borderBefore() const {
   switch (getWritingMode()) {
     case TopToBottomWritingMode:
       return borderTop();
     case LeftToRightWritingMode:
       return borderLeft();
@@ skipping 189 matching lines @@
 void ComputedStyle::setBorderImageOutset(const BorderImageLengthBox& outset) {
   if (m_surround->border.m_image.outset() == outset)
     return;
   m_surround.access()->border.m_image.setOutset(outset);
 }
 
 bool ComputedStyle::borderObscuresBackground() const {
   if (!hasBorder())
     return false;
 
-  // Bail if we have any border-image for now. We could look at the image alpha to improve this.
+  // Bail if we have any border-image for now. We could look at the image alpha
+  // to improve this.
   if (borderImage().image())
     return false;
 
   BorderEdge edges[4];
   getBorderEdgeInfo(edges);
 
   for (int i = BSTop; i <= BSLeft; ++i) {
     const BorderEdge& currEdge = edges[i];
     if (!currEdge.obscuresBackground())
       return false;
@@ skipping 51 matching lines @@
   return initialGridAutoTracks();
 }
 
 Vector<GridTrackSize> ComputedStyle::initialGridAutoRows() {
   return initialGridAutoTracks();
 }
 
 int adjustForAbsoluteZoom(int value, float zoomFactor) {
   if (zoomFactor == 1)
     return value;
-  // Needed because computeLengthInt truncates (rather than rounds) when scaling up.
+  // Needed because computeLengthInt truncates (rather than rounds) when scaling
+  // up.
   float fvalue = value;
   if (zoomFactor > 1) {
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 }  // namespace blink