Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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) 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
@@ skipping 21 matching lines @@
 namespace blink {
 
 namespace ListMarkerText {
 
 enum SequenceType { NumericSequence, AlphabeticSequence };
 
 static String toRoman(int number, bool upper) {
   // FIXME: CSS3 describes how to make this work for much larger numbers,
   // using overbars and special characters. It also specifies the characters
   // in the range U+2160 to U+217F instead of standard ASCII ones.
-  ASSERT(number >= 1 && number <= 3999);
+  DCHECK_GE(number, 1);
+  DCHECK_LE(number, 3999);
 
   // Big enough to store largest roman number less than 3999 which
   // is 3888 (MMMDCCCLXXXVIII)
   const int lettersSize = 15;
   LChar letters[lettersSize];
 
   int length = 0;
   const LChar ldigits[] = {'i', 'v', 'x', 'l', 'c', 'd', 'm'};
   const LChar udigits[] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};
   const LChar* digits = upper ? udigits : ldigits;
   int d = 0;
   do {
     int num = number % 10;
     if (num % 5 < 4)
       for (int i = num % 5; i > 0; i--)
         letters[lettersSize - ++length] = digits[d];
     if (num >= 4 && num <= 8)
       letters[lettersSize - ++length] = digits[d + 1];
     if (num == 9)
       letters[lettersSize - ++length] = digits[d + 2];
     if (num % 5 == 4)
       letters[lettersSize - ++length] = digits[d];
     number /= 10;
     d += 2;
   } while (number);
 
-  ASSERT(length <= lettersSize);
+  DCHECK_LE(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.
 typedef int numberType;
 
 template <typename CharacterType>
 static inline String toAlphabeticOrNumeric(numberType number,
                                            const CharacterType* sequence,
                                            unsigned sequenceSize,
                                            SequenceType type) {
-  ASSERT(sequenceSize >= 2);
+  DCHECK_GE(sequenceSize, 2u);
 
   // 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);
+    DCHECK_GT(number, 0);
     --numberShadow;
   } else if (number < 0) {
     numberShadow = -number;
     isNegativeNumber = true;
   }
   letters[lettersSize - 1] = sequence[numberShadow % sequenceSize];
   int length = 1;
 
   if (type == AlphabeticSequence) {
     while ((numberShadow /= sequenceSize) > 0) {
       --numberShadow;
       letters[lettersSize - ++length] = sequence[numberShadow % sequenceSize];
     }
   } else {
     while ((numberShadow /= sequenceSize) > 0)
       letters[lettersSize - ++length] = sequence[numberShadow % sequenceSize];
   }
   if (isNegativeNumber)
     letters[lettersSize - ++length] = hyphenMinusCharacter;
 
-  ASSERT(length <= lettersSize);
+  DCHECK_LE(length, lettersSize);
   return String(&letters[lettersSize - length], length);
 }
 
 template <typename CharacterType>
 static String toSymbolic(int number,
                          const CharacterType* symbols,
                          unsigned symbolsSize) {
-  ASSERT(number > 0);
-  ASSERT(symbolsSize >= 1);
+  DCHECK_GT(number, 0);
+  DCHECK_GE(symbolsSize, 1u);
   unsigned numberShadow = number;
   --numberShadow;
 
   // 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]);
@@ skipping 30 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).
-  ASSERT(number >= 0 && number < 1000);
+  DCHECK_GE(number, 0);
+  DCHECK_LT(number, 1000);
   int fourHundreds = number / 400;
   for (int i = 0; i < fourHundreds; i++)
     letters.push_front(1511 + 3);
   number %= 400;
   if (number / 100)
     letters.push_front(1511 + (number / 100) - 1);
   number %= 100;
   if (number == 15 || number == 16) {
     letters.push_front(1487 + 9);
     letters.push_front(1487 + number - 9);
   } else {
     if (int tens = number / 10) {
       static const UChar hebrewTens[9] = {1497, 1499, 1500, 1502, 1504,
                                           1505, 1506, 1508, 1510};
       letters.push_front(hebrewTens[tens - 1]);
     }
     if (int ones = number % 10)
       letters.push_front(1487 + ones);
   }
 }
 
 static String toHebrew(int number) {
   // FIXME: CSS3 mentions ways to make this work for much larger numbers.
-  ASSERT(number >= 0 && number <= 999999);
+  DCHECK_GE(number, 0);
+  DCHECK_LE(number, 999999);
 
   if (number == 0) {
     static const UChar hebrewZero[3] = {0x05E1, 0x05E4, 0x05D0};
     return String(hebrewZero, 3);
   }
 
   Vector<UChar> letters;
   if (number > 999) {
     toHebrewUnder1000(number / 1000, letters);
     letters.push_front('\'');
     number = number % 1000;
   }
   toHebrewUnder1000(number, letters);
   return String(letters);
 }
 
 static int toArmenianUnder10000(int number,
                                 bool upper,
                                 bool addCircumflex,
                                 UChar letters[9]) {
-  ASSERT(number >= 0 && number < 10000);
+  DCHECK_GE(number, 0);
+  DCHECK_LT(number, 10000);
   int length = 0;
 
   int lowerOffset = upper ? 0 : 0x0030;
 
   if (int thousands = number / 1000) {
     if (thousands == 7) {
       letters[length++] = 0x0552 + lowerOffset;
       if (addCircumflex)
         letters[length++] = 0x0302;
     } else {
@@ skipping 18 matching lines @@
   if (int ones = number % 10) {
     letters[length++] = (0x531 - 1 + lowerOffset) + ones;
     if (addCircumflex)
       letters[length++] = 0x0302;
   }
 
   return length;
 }
 
 static String toArmenian(int number, bool upper) {
-  ASSERT(number >= 1 && number <= 99999999);
+  DCHECK_GE(number, 1);
+  DCHECK_LE(number, 99999999);
 
   const int lettersSize = 18;  // twice what toArmenianUnder10000 needs
   UChar letters[lettersSize];
 
   int length = toArmenianUnder10000(number / 10000, upper, true, letters);
   length +=
       toArmenianUnder10000(number % 10000, upper, false, letters + length);
 
-  ASSERT(length <= lettersSize);
+  DCHECK_LE(length, lettersSize);
   return String(letters, length);
 }
 
 static String toGeorgian(int number) {
-  ASSERT(number >= 1 && number <= 19999);
+  DCHECK_GE(number, 1);
+  DCHECK_LE(number, 19999);
 
   const int lettersSize = 5;
   UChar letters[lettersSize];
 
   int length = 0;
 
   if (number > 9999)
     letters[length++] = 0x10F5;
 
   if (int thousands = (number / 1000) % 10) {
@@ skipping 13 matching lines @@
         0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10F2, 0x10DD, 0x10DE, 0x10DF};
     letters[length++] = georgianTens[tens - 1];
   }
 
   if (int ones = number % 10) {
     static const UChar georgianOnes[9] = {
         0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10F1, 0x10D7};
     letters[length++] = georgianOnes[ones - 1];
   }
 
-  ASSERT(length <= lettersSize);
+  DCHECK_LE(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.
@@ skipping 93 matching lines @@
 
     if (trailingZero && i > 0) {
       group[6] = group[7];
       group[7] = group[8];
       group[8] = Digit0;
     }
 
     // Remove the tens digit, but leave the marker, for any group that has
     // a value of less than 20.
     if (table[Lang] == Chinese && cjkStyle == Informal && groupValue < 20) {
-      ASSERT(group[4] == NoChar || group[4] == Digit0 || group[4] == Digit1);
+      DCHECK(group[4] == NoChar || group[4] == Digit0 || group[4] == Digit1);
       group[4] = NoChar;
     }
 
     if (number == 0)
       break;
   }
 
   // Convert into characters, omitting consecutive runs of Digit0 and
   // any trailing Digit0.
   int length = 0;
@@ skipping 503 matching lines @@
       return toHebrew(count);
   }
 
   NOTREACHED();
   return "";
 }
 
 }  // namespace ListMarkerText
 
 }  // namespace blink