Reflow comments in core/css

third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
+ * All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 118 matching lines @@
         *CSSIdentifierValue::create(layer.backgroundYOrigin()));
   }
   positionList->append(
       *zoomAdjustedPixelValueForLength(layer.yPosition(), style));
   return positionList;
 }
 
 CSSValue* ComputedStyleCSSValueMapping::currentColorOrValidColor(
     const ComputedStyle& style,
     const StyleColor& color) {
-  // This function does NOT look at visited information, so that computed style doesn't expose that.
+  // This function does NOT look at visited information, so that computed style
+  // doesn't expose that.
   return CSSColorValue::create(color.resolve(style.color()).rgb());
 }
 
 static CSSValue* valueForFillSize(const FillSize& fillSize,
                                   const ComputedStyle& style) {
   if (fillSize.type == Contain)
     return CSSIdentifierValue::create(CSSValueContain);
 
   if (fillSize.type == Cover)
     return CSSIdentifierValue::create(CSSValueCover);
 
   if (fillSize.size.height().isAuto())
     return zoomAdjustedPixelValueForLength(fillSize.size.width(), style);
 
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   list->append(*zoomAdjustedPixelValueForLength(fillSize.size.width(), style));
   list->append(*zoomAdjustedPixelValueForLength(fillSize.size.height(), style));
   return list;
 }
 
 static CSSValue* valueForFillRepeat(EFillRepeat xRepeat, EFillRepeat yRepeat) {
-  // For backwards compatibility, if both values are equal, just return one of them. And
-  // if the two values are equivalent to repeat-x or repeat-y, just return the shorthand.
+  // For backwards compatibility, if both values are equal, just return one of
+  // them. And if the two values are equivalent to repeat-x or repeat-y, just
+  // return the shorthand.
   if (xRepeat == yRepeat)
     return CSSIdentifierValue::create(xRepeat);
   if (xRepeat == RepeatFill && yRepeat == NoRepeatFill)
     return CSSIdentifierValue::create(CSSValueRepeatX);
   if (xRepeat == NoRepeatFill && yRepeat == RepeatFill)
     return CSSIdentifierValue::create(CSSValueRepeatY);
 
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   list->append(*CSSIdentifierValue::create(xRepeat));
   list->append(*CSSIdentifierValue::create(yRepeat));
@@ skipping 43 matching lines @@
     LayoutUnit containingBlockSize =
         (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight)
             ? toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent()
             : toLayoutBox(layoutObject)
                   ->containingBlockLogicalHeightForGetComputedStyle();
     return zoomAdjustedPixelValue(valueForLength(offset, containingBlockSize),
                                   style);
   }
 
   if (offset.isAuto() && layoutObject) {
-    // If the property applies to a positioned element and the resolved value of the display
-    // property is not none, the resolved value is the used value.
+    // If the property applies to a positioned element and the resolved value of
+    // the display property is not none, the resolved value is the used value.
     if (layoutObject->isInFlowPositioned()) {
-      // If e.g. left is auto and right is not auto, then left's computed value is negative right.
-      // So we get the opposite length unit and see if it is auto.
+      // If e.g. left is auto and right is not auto, then left's computed value
+      // is negative right. So we get the opposite length unit and see if it is
+      // auto.
       if (opposite.isAuto())
         return CSSPrimitiveValue::create(0,
                                          CSSPrimitiveValue::UnitType::Pixels);
 
       if (opposite.isPercentOrCalc() || opposite.isCalculated()) {
         if (layoutObject->isBox()) {
           LayoutUnit containingBlockSize =
               (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight)
                   ? toLayoutBox(layoutObject)
                         ->containingBlockLogicalWidthForContent()
                   : toLayoutBox(layoutObject)
                         ->containingBlockLogicalHeightForGetComputedStyle();
           return zoomAdjustedPixelValue(
               -floatValueForLength(opposite, containingBlockSize), style);
         }
         // FIXME:  fall back to auto for position:relative, display:inline
         return CSSIdentifierValue::create(CSSValueAuto);
       }
 
       // Length doesn't provide operator -, so multiply by -1.
       opposite *= -1.f;
       return zoomAdjustedPixelValueForLength(opposite, style);
     }
 
     if (layoutObject->isOutOfFlowPositioned() && layoutObject->isBox()) {
-      // For fixed and absolute positioned elements, the top, left, bottom, and right
-      // are defined relative to the corresponding sides of the containing block.
+      // For fixed and absolute positioned elements, the top, left, bottom, and
+      // right are defined relative to the corresponding sides of the containing
+      // block.
       LayoutBlock* container = layoutObject->containingBlock();
       const LayoutBox* layoutBox = toLayoutBox(layoutObject);
 
-      // clientOffset is the distance from this object's border edge to the container's
-      // padding edge. Thus it includes margins which we subtract below.
+      // clientOffset is the distance from this object's border edge to the
+      // container's padding edge. Thus it includes margins which we subtract
+      // below.
       const LayoutSize clientOffset =
           layoutBox->locationOffset() -
           LayoutSize(container->clientLeft(), container->clientTop());
       LayoutUnit position;
 
       switch (propertyID) {
         case CSSPropertyLeft:
           position = clientOffset.width() - layoutBox->marginLeft();
           break;
         case CSSPropertyTop:
@@ skipping 214 matching lines @@
 
   return CSSReflectValue::create(
       direction, offset, valueForNinePieceImage(reflection->mask(), style));
 }
 
 static CSSValueList* valueForItemPositionWithOverflowAlignment(
     const StyleSelfAlignmentData& data) {
   CSSValueList* result = CSSValueList::createSpaceSeparated();
   if (data.positionType() == LegacyPosition)
     result->append(*CSSIdentifierValue::create(CSSValueLegacy));
-  // 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.
   result->append(*CSSIdentifierValue::create(
       data.position() == ItemPositionAuto
           ? ComputedStyle::initialDefaultAlignment().position()
           : data.position()));
   if (data.position() >= ItemPositionCenter &&
       data.overflow() != OverflowAlignmentDefault)
     result->append(*CSSIdentifierValue::create(data.overflow()));
   ASSERT(result->length() <= 2);
   return result;
 }
@@ skipping 487 matching lines @@
   const Vector<GridTrackSize>& trackSizes =
       isRowAxis ? style.gridTemplateColumns() : style.gridTemplateRows();
   const Vector<GridTrackSize>& autoRepeatTrackSizes =
       isRowAxis ? style.gridAutoRepeatColumns() : style.gridAutoRepeatRows();
   bool isLayoutGrid = layoutObject && layoutObject->isLayoutGrid();
 
   // Handle the 'none' case.
   bool trackListIsEmpty =
       trackSizes.isEmpty() && autoRepeatTrackSizes.isEmpty();
   if (isLayoutGrid && trackListIsEmpty) {
-    // For grids we should consider every listed track, whether implicitly or explicitly
-    // created. Empty grids have a sole grid line per axis.
+    // For grids we should consider every listed track, whether implicitly or
+    // explicitly created. Empty grids have a sole grid line per axis.
     auto& positions = isRowAxis ? toLayoutGrid(layoutObject)->columnPositions()
                                 : toLayoutGrid(layoutObject)->rowPositions();
     trackListIsEmpty = positions.size() == 1;
   }
 
   if (trackListIsEmpty)
     return CSSIdentifierValue::create(CSSValueNone);
 
   size_t autoRepeatTotalTracks =
       isLayoutGrid
@@ skipping 371 matching lines @@
   IntRect box;
   if (layoutObject->isBox())
     box = pixelSnappedIntRect(toLayoutBox(layoutObject)->borderBoxRect());
 
   TransformationMatrix transform;
   style.applyTransform(transform, LayoutSize(box.size()),
                        ComputedStyle::ExcludeTransformOrigin,
                        ComputedStyle::ExcludeMotionPath,
                        ComputedStyle::ExcludeIndependentTransformProperties);
 
-  // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
+  // FIXME: Need to print out individual functions
+  // (https://bugs.webkit.org/show_bug.cgi?id=23924)
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   list->append(*valueForMatrixTransform(transform, style));
 
   return list;
 }
 
 static CSSValue* createTransitionPropertyValue(
     const CSSTransitionData::TransitionProperty& property) {
   if (property.propertyType == CSSTransitionData::TransitionNone)
     return CSSIdentifierValue::create(CSSValueNone);
@@ skipping 372 matching lines @@
       case FilterOperation::BLUR:
         filterValue = CSSFunctionValue::create(CSSValueBlur);
         filterValue->append(*zoomAdjustedPixelValue(
             toBlurFilterOperation(filterOperation)->stdDeviation().value(),
             style));
         break;
       case FilterOperation::DROP_SHADOW: {
         DropShadowFilterOperation* dropShadowOperation =
             toDropShadowFilterOperation(filterOperation);
         filterValue = CSSFunctionValue::create(CSSValueDropShadow);
-        // We want our computed style to look like that of a text shadow (has neither spread nor inset style).
+        // We want our computed style to look like that of a text shadow (has
+        // neither spread nor inset style).
         ShadowData shadow(dropShadowOperation->location(),
                           dropShadowOperation->stdDeviation(), 0, Normal,
                           StyleColor(dropShadowOperation->getColor()));
         filterValue->append(*valueForShadowData(shadow, style, false));
         break;
       }
       default:
         ASSERT_NOT_REACHED();
         break;
     }
     list->append(*filterValue);
   }
 
   return list;
 }
 
 CSSValue* ComputedStyleCSSValueMapping::valueForFont(
     const ComputedStyle& style) {
   // Add a slash between size and line-height.
   CSSValueList* sizeAndLineHeight = CSSValueList::createSlashSeparated();
   sizeAndLineHeight->append(*valueForFontSize(style));
   sizeAndLineHeight->append(*valueForLineHeight(style));
 
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   list->append(*valueForFontStyle(style));
 
-  // Check that non-initial font-variant subproperties are not conflicting with this serialization.
+  // Check that non-initial font-variant subproperties are not conflicting with
+  // this serialization.
   CSSValue* ligaturesValue = valueForFontVariantLigatures(style);
   CSSValue* numericValue = valueForFontVariantNumeric(style);
   if (!ligaturesValue->equals(*CSSIdentifierValue::create(CSSValueNormal)) ||
       !numericValue->equals(*CSSIdentifierValue::create(CSSValueNormal)))
     return nullptr;
 
   CSSIdentifierValue* capsValue = valueForFontVariantCaps(style);
   if (capsValue->getValueID() != CSSValueNormal &&
       capsValue->getValueID() != CSSValueSmallCaps)
     return nullptr;
@@ skipping 515 matching lines @@
         case AutoFlowColumnDense:
           list->append(*CSSIdentifierValue::create(CSSValueDense));
           break;
         default:
           // Do nothing.
           break;
       }
 
       return list;
     }
-    // Specs mention that getComputedStyle() should return the used value of the property instead of the computed
-    // one for grid-template-{rows|columns} but not for the grid-auto-{rows|columns} as things like
-    // grid-auto-columns: 2fr; cannot be resolved to a value in pixels as the '2fr' means very different things
-    // depending on the size of the explicit grid or the number of implicit tracks added to the grid. See
+    // Specs mention that getComputedStyle() should return the used value of the
+    // property instead of the computed one for grid-template-{rows|columns} but
+    // not for the grid-auto-{rows|columns} as things like grid-auto-columns:
+    // 2fr; cannot be resolved to a value in pixels as the '2fr' means very
+    // different things depending on the size of the explicit grid or the number
+    // of implicit tracks added to the grid. See
     // http://lists.w3.org/Archives/Public/www-style/2013Nov/0014.html
     case CSSPropertyGridAutoColumns:
       return valueForGridTrackSizeList(ForColumns, style);
     case CSSPropertyGridAutoRows:
       return valueForGridTrackSizeList(ForRows, style);
 
     case CSSPropertyGridTemplateColumns:
       return valueForGridTrackList(ForColumns, layoutObject, style);
     case CSSPropertyGridTemplateRows:
       return valueForGridTrackList(ForRows, layoutObject, style);
@@ skipping 34 matching lines @@
     case CSSPropertyGridColumnGap:
       return zoomAdjustedPixelValueForLength(style.gridColumnGap(), style);
     case CSSPropertyGridRowGap:
       return zoomAdjustedPixelValueForLength(style.gridRowGap(), style);
     case CSSPropertyGridGap:
       return valuesForShorthandProperty(gridGapShorthand(), style, layoutObject,
                                         styledNode, allowVisitedStyle);
 
     case CSSPropertyHeight:
       if (layoutObject) {
-        // According to http://www.w3.org/TR/CSS2/visudet.html#the-height-property,
-        // the "height" property does not apply for non-atomic inline elements.
+        // According to
+        // http://www.w3.org/TR/CSS2/visudet.html#the-height-property, the
+        // "height" property does not apply for non-atomic inline elements.
         if (!layoutObject->isAtomicInlineLevel() && layoutObject->isInline())
           return CSSIdentifierValue::create(CSSValueAuto);
         return zoomAdjustedPixelValue(sizingBox(layoutObject).height(), style);
       }
       return zoomAdjustedPixelValueForLength(style.height(), style);
     case CSSPropertyWebkitHighlight:
       if (style.highlight() == nullAtom)
         return CSSIdentifierValue::create(CSSValueNone);
       return CSSStringValue::create(style.highlight());
     case CSSPropertyHyphens:
@@ skipping 48 matching lines @@
         return zoomAdjustedPixelValueForLength(marginTop, style);
       return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginTop(),
                                     style);
     }
     case CSSPropertyMarginRight: {
       Length marginRight = style.marginRight();
       if (marginRight.isFixed() || !layoutObject || !layoutObject->isBox())
         return zoomAdjustedPixelValueForLength(marginRight, style);
       float value;
       if (marginRight.isPercentOrCalc()) {
-        // LayoutBox gives a marginRight() that is the distance between the right-edge of the child box
-        // and the right-edge of the containing box, when display == EDisplay::Block. Let's calculate the absolute
-        // value of the specified margin-right % instead of relying on LayoutBox's marginRight() value.
+        // LayoutBox gives a marginRight() that is the distance between the
+        // right-edge of the child box and the right-edge of the containing box,
+        // when display == EDisplay::Block. Let's calculate the absolute value
+        // of the specified margin-right % instead of relying on LayoutBox's
+        // marginRight() value.
         value = minimumValueForLength(
                     marginRight, toLayoutBox(layoutObject)
                                      ->containingBlockLogicalWidthForContent())
                     .toFloat();
       } else {
         value = toLayoutBox(layoutObject)->marginRight().toFloat();
       }
       return zoomAdjustedPixelValue(value, style);
     }
     case CSSPropertyMarginBottom: {
@@ skipping 118 matching lines @@
     case CSSPropertyPageBreakBefore:
       return CSSIdentifierValue::create(
           mapToPageBreakValue(style.breakBefore()));
     case CSSPropertyPageBreakInside:
       return CSSIdentifierValue::create(
           mapToPageBreakValue(style.breakInside()));
     case CSSPropertyPosition:
       return CSSIdentifierValue::create(style.position());
     case CSSPropertyQuotes:
       if (!style.quotes()) {
-        // TODO(ramya.v): We should return the quote values that we're actually using.
+        // TODO(ramya.v): We should return the quote values that we're actually
+        // using.
         return nullptr;
       }
       if (style.quotes()->size()) {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         for (int i = 0; i < style.quotes()->size(); i++) {
           list->append(
               *CSSStringValue::create(style.quotes()->getOpenQuote(i)));
           list->append(
               *CSSStringValue::create(style.quotes()->getCloseQuote(i)));
         }
@@ skipping 123 matching lines @@
       return nullptr;
     case CSSPropertyVisibility:
       return CSSIdentifierValue::create(style.visibility());
     case CSSPropertyWhiteSpace:
       return CSSIdentifierValue::create(style.whiteSpace());
     case CSSPropertyWidows:
       return CSSPrimitiveValue::create(style.widows(),
                                        CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyWidth:
       if (layoutObject) {
-        // According to http://www.w3.org/TR/CSS2/visudet.html#the-width-property,
+        // According to
+        // http://www.w3.org/TR/CSS2/visudet.html#the-width-property,
         // the "width" property does not apply for non-atomic inline elements.
         if (!layoutObject->isAtomicInlineLevel() && layoutObject->isInline())
           return CSSIdentifierValue::create(CSSValueAuto);
         return zoomAdjustedPixelValue(sizingBox(layoutObject).width(), style);
       }
       return zoomAdjustedPixelValueForLength(style.width(), style);
     case CSSPropertyWillChange:
       return valueForWillChange(style.willChangeProperties(),
                                 style.willChangeContents(),
                                 style.willChangeScrollPosition());
@@ skipping 184 matching lines @@
     case CSSPropertyWebkitMaskBoxImageSlice:
       return valueForNinePieceImageSlice(style.maskBoxImage());
     case CSSPropertyWebkitMaskBoxImageWidth:
       return valueForNinePieceImageQuad(style.maskBoxImage().borderSlices(),
                                         style);
     case CSSPropertyWebkitMaskBoxImageSource:
       if (style.maskBoxImageSource())
         return style.maskBoxImageSource()->computedCSSValue();
       return CSSIdentifierValue::create(CSSValueNone);
     case CSSPropertyWebkitFontSizeDelta:
-      // Not a real style property -- used by the editing engine -- so has no computed value.
+      // Not a real style property -- used by the editing engine -- so has no
+      // computed value.
       return nullptr;
     case CSSPropertyWebkitMarginBottomCollapse:
     case CSSPropertyWebkitMarginAfterCollapse:
       return CSSIdentifierValue::create(style.marginAfterCollapse());
     case CSSPropertyWebkitMarginTopCollapse:
     case CSSPropertyWebkitMarginBeforeCollapse:
       return CSSIdentifierValue::create(style.marginBeforeCollapse());
     case CSSPropertyPerspective:
       if (!style.hasPerspective())
         return CSSIdentifierValue::create(CSSValueNone);
@@ skipping 283 matching lines @@
         list->append(*CSSIdentifierValue::create(CSSValueAuto));
       list->append(*CSSPrimitiveValue::create(
           style.offsetRotation().angle, CSSPrimitiveValue::UnitType::Degrees));
       return list;
     }
 
     // Unimplemented CSS 3 properties (including CSS3 shorthand properties).
     case CSSPropertyWebkitTextEmphasis:
       return nullptr;
 
-    // Directional properties are resolved by resolveDirectionAwareProperty() before the switch.
+    // Directional properties are resolved by resolveDirectionAwareProperty()
+    // before the switch.
     case CSSPropertyWebkitBorderEnd:
     case CSSPropertyWebkitBorderEndColor:
     case CSSPropertyWebkitBorderEndStyle:
     case CSSPropertyWebkitBorderEndWidth:
     case CSSPropertyWebkitBorderStart:
     case CSSPropertyWebkitBorderStartColor:
     case CSSPropertyWebkitBorderStartStyle:
     case CSSPropertyWebkitBorderStartWidth:
     case CSSPropertyWebkitBorderAfter:
     case CSSPropertyWebkitBorderAfterColor:
@@ skipping 289 matching lines @@
     case CSSPropertyAll:
       return nullptr;
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return nullptr;
 }
 
 }  // namespace blink