Reflow comments in core/css

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

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All
+ * rights reserved.
  * Copyright (C) 2011 Research In Motion Limited. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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 397 matching lines @@
     if (value.isVariableReferenceValue())
       return emptyString();
   }
 
   return String();
 }
 
 String StylePropertySerializer::getPropertyValue(
     CSSPropertyID propertyID) const {
   const StylePropertyShorthand& shorthand = shorthandForProperty(propertyID);
-  // TODO(timloh): This is weird, why do we call this with non-shorthands at all?
+  // TODO(timloh): This is weird, why do we call this with non-shorthands at
+  // all?
   if (!shorthand.length())
     return String();
 
   String result = commonShorthandChecks(shorthand);
   if (!result.isNull())
     return result;
 
   switch (propertyID) {
     case CSSPropertyAnimation:
       return getLayeredShorthandValue(animationShorthand());
@@ skipping 123 matching lines @@
       prefix = '/';
       break;
     default:
       ASSERT_NOT_REACHED();
   }
 
   if (prefix && !result.isEmpty())
     result.append(prefix);
 
   String value;
-  // In the font-variant shorthand a "none" ligatures value needs to be expanded.
+  // In the font-variant shorthand a "none" ligatures value needs to be
+  // expanded.
   if (propertyID == CSSPropertyFontVariantLigatures &&
       val->isIdentifierValue() &&
       toCSSIdentifierValue(val)->getValueID() == CSSValueNone) {
     value =
         "no-common-ligatures no-discretionary-ligatures "
         "no-historical-ligatures no-contextual";
   } else {
     value = m_propertySet.propertyAt(foundPropertyIndex).value()->cssText();
   }
 
@@ skipping 21 matching lines @@
       m_propertySet.propertyAt(fontSizePropertyIndex);
   PropertyValueForSerializer fontFamilyProperty =
       m_propertySet.propertyAt(fontFamilyPropertyIndex);
   PropertyValueForSerializer fontVariantCapsProperty =
       m_propertySet.propertyAt(fontVariantCapsPropertyIndex);
   PropertyValueForSerializer fontVariantLigaturesProperty =
       m_propertySet.propertyAt(fontVariantLigaturesPropertyIndex);
   PropertyValueForSerializer fontVariantNumericProperty =
       m_propertySet.propertyAt(fontVariantNumericPropertyIndex);
 
-  // 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.
   const CSSValue* ligaturesValue = fontVariantLigaturesProperty.value();
   const CSSValue* numericValue = fontVariantNumericProperty.value();
   if ((ligaturesValue->isIdentifierValue() &&
        toCSSIdentifierValue(ligaturesValue)->getValueID() != CSSValueNormal) ||
       ligaturesValue->isValueList() ||
       (numericValue->isIdentifierValue() &&
        toCSSIdentifierValue(numericValue)->getValueID() != CSSValueNormal) ||
       numericValue->isValueList())
     return emptyString();
 
@@ skipping 15 matching lines @@
   appendFontLonghandValueIfNotNormal(CSSPropertyLineHeight, result);
   if (!result.isEmpty())
     result.append(' ');
   result.append(fontFamilyProperty.value()->cssText());
   return result.toString();
 }
 
 String StylePropertySerializer::fontVariantValue() const {
   StringBuilder result;
 
-  // TODO(drott): Decide how we want to return ligature values in shorthands, reduced to "none" or
-  // spelled out, filed as W3C bug:
+  // TODO(drott): Decide how we want to return ligature values in shorthands,
+  // reduced to "none" or spelled out, filed as W3C bug:
   // https://www.w3.org/Bugs/Public/show_bug.cgi?id=29594
   appendFontLonghandValueIfNotNormal(CSSPropertyFontVariantLigatures, result);
   appendFontLonghandValueIfNotNormal(CSSPropertyFontVariantCaps, result);
   appendFontLonghandValueIfNotNormal(CSSPropertyFontVariantNumeric, result);
 
   if (result.isEmpty()) {
     return "normal";
   }
 
   return result.toString();
@@ skipping 54 matching lines @@
   for (size_t i = 0; i < size; i++) {
     values[i] = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
     if (values[i]->isBaseValueList()) {
       const CSSValueList* valueList = toCSSValueList(values[i]);
       numLayers = std::max(numLayers, valueList->length());
     }
   }
 
   StringBuilder result;
 
-  // Now stitch the properties together. Implicit initial values are flagged as such and
+  // Now stitch the properties together. Implicit initial values are flagged as
+  // such and
   // can safely be omitted.
   for (size_t layer = 0; layer < numLayers; layer++) {
     StringBuilder layerResult;
     bool useRepeatXShorthand = false;
     bool useRepeatYShorthand = false;
     bool useSingleWordShorthand = false;
     bool foundPositionXCSSProperty = false;
     bool foundPositionYCSSProperty = false;
 
     for (unsigned propertyIndex = 0; propertyIndex < size; propertyIndex++) {
@@ skipping 24 matching lines @@
            property == CSSPropertyWebkitMaskRepeatX)) {
         ASSERT(shorthand.properties()[propertyIndex + 1] ==
                    CSSPropertyBackgroundRepeatY ||
                shorthand.properties()[propertyIndex + 1] ==
                    CSSPropertyWebkitMaskRepeatY);
         const CSSValue& yValue =
             values[propertyIndex + 1]->isValueList()
                 ? toCSSValueList(values[propertyIndex + 1])->item(layer)
                 : *values[propertyIndex + 1];
 
-        // FIXME: At some point we need to fix this code to avoid returning an invalid shorthand,
-        // since some longhand combinations are not serializable into a single shorthand.
+        // FIXME: At some point we need to fix this code to avoid returning an
+        // invalid shorthand, since some longhand combinations are not
+        // serializable into a single shorthand.
         if (!value->isIdentifierValue() || !yValue.isIdentifierValue())
           continue;
 
         CSSValueID xId = toCSSIdentifierValue(value)->getValueID();
         CSSValueID yId = toCSSIdentifierValue(yValue).getValueID();
-        // Maybe advance propertyIndex to look at the next CSSValue in the list for the checks below.
+        // Maybe advance propertyIndex to look at the next CSSValue in the list
+        // for the checks below.
         if (xId == yId) {
           useSingleWordShorthand = true;
           property = shorthand.properties()[++propertyIndex];
         } else if (xId == CSSValueRepeat && yId == CSSValueNoRepeat) {
           useRepeatXShorthand = true;
           property = shorthand.properties()[++propertyIndex];
         } else if (xId == CSSValueNoRepeat && yId == CSSValueRepeat) {
           useRepeatYShorthand = true;
           property = shorthand.properties()[++propertyIndex];
         }
       }
 
       if (!(value->isInitialValue() &&
             toCSSInitialValue(value)->isImplicit())) {
         if (property == CSSPropertyBackgroundSize ||
             property == CSSPropertyWebkitMaskSize) {
           if (foundPositionYCSSProperty || foundPositionXCSSProperty)
             layerResult.append(" / ");
           else
             layerResult.append(" 0% 0% / ");
         } else if (!layerResult.isEmpty()) {
-          // Do this second to avoid ending up with an extra space in the output if we hit the continue above.
+          // Do this second to avoid ending up with an extra space in the output
+          // if we hit the continue above.
           layerResult.append(' ');
         }
 
         if (useRepeatXShorthand) {
           useRepeatXShorthand = false;
           layerResult.append(getValueName(CSSValueRepeatX));
         } else if (useRepeatYShorthand) {
           useRepeatYShorthand = false;
           layerResult.append(getValueName(CSSValueRepeatY));
         } else {
           if (useSingleWordShorthand)
             useSingleWordShorthand = false;
           layerResult.append(value->cssText());
         }
         if (property == CSSPropertyBackgroundPositionX ||
             property == CSSPropertyWebkitMaskPositionX)
           foundPositionXCSSProperty = true;
         if (property == CSSPropertyBackgroundPositionY ||
             property == CSSPropertyWebkitMaskPositionY) {
           foundPositionYCSSProperty = true;
-          // background-position is a special case. If only the first offset is specified,
-          // the second one defaults to "center", not the same value.
+          // background-position is a special case. If only the first offset is
+          // specified, the second one defaults to "center", not the same value.
         }
       }
     }
     if (!layerResult.isEmpty()) {
       if (!result.isEmpty())
         result.append(", ");
       result.append(layerResult);
     }
   }
 
@@ skipping 113 matching lines @@
     const CSSValue& xValue =
         repeatXList ? repeatXList->item(i % repeatXList->length()) : repeatX;
     const CSSValue& yValue =
         repeatYList ? repeatYList->item(i % repeatYList->length()) : repeatY;
     appendBackgroundRepeatValue(builder, xValue, yValue);
   }
   return builder.toString();
 }
 
 }  // namespace blink