Enforce comment formatting in core/layout as well.

third_party/WebKit/Source/core/layout/ListMarkerText.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights
+ * reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2010 Daniel Bates (dbates@intudata.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
@@ skipping 47 matching lines @@
     if (num % 5 == 4)
       letters[lettersSize - ++length] = digits[d];
     number /= 10;
     d += 2;
   } while (number);
 
   ASSERT(length <= lettersSize);
   return String(&letters[lettersSize - length], length);
 }
 
-// The typedef is needed because taking sizeof(number) in the const expression below doesn't work with some compilers.
-// This is likely the case because of the template.
+// The typedef is needed because taking sizeof(number) in the const expression
+// below doesn't work with some compilers. This is likely the case because of
+// the template.
 typedef int numberType;
 
 template <typename CharacterType>
 static inline String toAlphabeticOrNumeric(numberType number,
                                            const CharacterType* sequence,
                                            unsigned sequenceSize,
                                            SequenceType type) {
   ASSERT(sequenceSize >= 2);
 
-  const int lettersSize =
-      sizeof(numberType) * 8 +
-      1;  // Binary is the worst case; requires one character per bit plus a minus sign.
+  // Binary is the worst case; requires one character per bit plus a minus sign.
+  const int lettersSize = sizeof(numberType) * 8 + 1;
 
   CharacterType letters[lettersSize];
 
   bool isNegativeNumber = false;
   unsigned numberShadow = number;
   if (type == AlphabeticSequence) {
     ASSERT(number > 0);
     --numberShadow;
   } else if (number < 0) {
     numberShadow = -number;
@@ skipping 20 matching lines @@
 
 template <typename CharacterType>
 static String toSymbolic(int number,
                          const CharacterType* symbols,
                          unsigned symbolsSize) {
   ASSERT(number > 0);
   ASSERT(symbolsSize >= 1);
   unsigned numberShadow = number;
   --numberShadow;
 
-  // The asterisks list-style-type is the worst case; we show |numberShadow| asterisks.
+  // The asterisks list-style-type is the worst case; we show |numberShadow|
+  // asterisks.
   StringBuilder letters;
   letters.append(symbols[numberShadow % symbolsSize]);
   unsigned numSymbols = numberShadow / symbolsSize;
   while (numSymbols--)
     letters.append(symbols[numberShadow % symbolsSize]);
   return letters.toString();
 }
 
 template <typename CharacterType>
 static String toAlphabetic(int number,
@@ skipping 23 matching lines @@
 }
 
 template <typename CharacterType, size_t size>
 static inline String toSymbolic(int number,
                                 const CharacterType (&alphabet)[size]) {
   return toSymbolic(number, alphabet, size);
 }
 
 static void toHebrewUnder1000(int number, Vector<UChar>& letters) {
   // FIXME: CSS3 mentions various refinements not implemented here.
-  // FIXME: Should take a look at Mozilla's HebrewToText function (in nsBulletFrame).
+  // FIXME: Should take a look at Mozilla's HebrewToText function (in
+  // nsBulletFrame).
   ASSERT(number >= 0 && number < 1000);
   int fourHundreds = number / 400;
   for (int i = 0; i < fourHundreds; i++)
     letters.prepend(1511 + 3);
   number %= 400;
   if (number / 100)
     letters.prepend(1511 + (number / 100) - 1);
   number %= 100;
   if (number == 15 || number == 16) {
     letters.prepend(1487 + 9);
@@ skipping 121 matching lines @@
 
   ASSERT(length <= lettersSize);
   return String(letters, length);
 }
 
 enum CJKLang { Chinese = 1, Korean, Japanese };
 
 enum CJKStyle { Formal, Informal };
 
 // The table uses the order from the CSS3 specification:
-// first 3 group markers, then 3 digit markers, then ten digits, then negative symbols.
+// first 3 group markers, then 3 digit markers, then ten digits, then negative
+// symbols.
 static String toCJKIdeographic(int number,
                                const UChar table[26],
                                CJKStyle cjkStyle) {
   enum AbstractCJKChar {
     NoChar = 0,
     Lang = 0,
     // FourthGroupMarker for simplified chinese has two codepoints, to simplify
     // the main algorithm below use two codepoints for all group markers.
     SecondGroupMarker = 1,
     ThirdGroupMarker = 3,
@@ skipping 198 matching lines @@
     case UpperLatin:
       return (count < 1) ? DecimalListStyle : type;
   }
 
   ASSERT_NOT_REACHED();
   return type;
 }
 
 UChar suffix(EListStyleType type, int count) {
   // If the list-style-type cannot represent |count| because it's outside its
-  // ordinal range then we fall back to some list style that can represent |count|.
+  // ordinal range then we fall back to some list style that can represent
+  // |count|.
   EListStyleType effectiveType = effectiveListMarkerType(type, count);
 
   // Note, the following switch statement has been explicitly
   // grouped by list-style-type suffix.
   switch (effectiveType) {
     case Circle:
     case Disc:
     case NoneListStyle:
     case Square:
       return ' ';
@@ skipping 52 matching lines @@
     case KoreanHanjaFormal:
     case KoreanHanjaInformal:
       return 0x3001;
   }
 
   ASSERT_NOT_REACHED();
   return '.';
 }
 
 String text(EListStyleType type, int count) {
-  // If the list-style-type, say hebrew, cannot represent |count| because it's outside
-  // its ordinal range then we fallback to some list style that can represent |count|.
+  // If the list-style-type, say hebrew, cannot represent |count| because it's
+  // outside its ordinal range then we fallback to some list style that can
+  // represent |count|.
   switch (effectiveListMarkerType(type, count)) {
     case NoneListStyle:
       return "";
 
     // We use the same characters for text security.
     // See LayoutText::setInternalString.
     case Circle:
       return String(&whiteBulletCharacter, 1);
     case Disc:
       return String(&bulletCharacter, 1);
@@ skipping 294 matching lines @@
     }
 
     case LowerRoman:
       return toRoman(count, false);
     case UpperRoman:
       return toRoman(count, true);
 
     case Armenian:
     case UpperArmenian:
       // CSS3 says "armenian" means "lower-armenian".
-      // But the CSS2.1 test suite contains uppercase test results for "armenian",
-      // so we'll match the test suite.
+      // But the CSS2.1 test suite contains uppercase test results for
+      // "armenian", so we'll match the test suite.
       return toArmenian(count, true);
     case LowerArmenian:
       return toArmenian(count, false);
     case Georgian:
       return toGeorgian(count);
     case Hebrew:
       return toHebrew(count);
   }
 
   ASSERT_NOT_REACHED();
   return "";
 }
 
 }  // namespace ListMarkerText
 
 }  // namespace blink