Replace ASSERT with DHCECK_op in platform/wtf

third_party/WebKit/Source/platform/wtf/dtoa/fixed-dtoa.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 37 matching lines @@
             uint32_t part = static_cast<uint32_t>(accumulator & kMask32);
             accumulator >>= 32;
             accumulator = accumulator + (low_bits_ >> 32) * multiplicand;
             low_bits_ = (accumulator << 32) + part;
             accumulator >>= 32;
             accumulator = accumulator + (high_bits_ & kMask32) * multiplicand;
             part = static_cast<uint32_t>(accumulator & kMask32);
             accumulator >>= 32;
             accumulator = accumulator + (high_bits_ >> 32) * multiplicand;
             high_bits_ = (accumulator << 32) + part;
-            ASSERT((accumulator >> 32) == 0);
+            DCHECK_EQ((accumulator >> 32), 0u);
         }
 
         void Shift(int shift_amount) {
-            ASSERT(-64 <= shift_amount && shift_amount <= 64);
+            DCHECK_LE(-64, shift_amount);
+            DCHECK_LE(shift_amount, 64);
             if (shift_amount == 0) {
                 return;
             } else if (shift_amount == -64) {
                 high_bits_ = low_bits_;
                 low_bits_ = 0;
             } else if (shift_amount == 64) {
                 low_bits_ = high_bits_;
                 high_bits_ = 0;
             } else if (shift_amount <= 0) {
                 high_bits_ <<= -shift_amount;
@@ skipping 152 matching lines @@
     //   0 <= fractionals * 2^exponent < 1
     //   The buffer holds the result.
     // The function will round its result. During the rounding-process digits not
     // generated by this function might be updated, and the decimal-point variable
     // might be updated. If this function generates the digits 99 and the buffer
     // already contained "199" (thus yielding a buffer of "19999") then a
     // rounding-up will change the contents of the buffer to "20000".
     static void FillFractionals(uint64_t fractionals, int exponent,
                                 int fractional_count, Vector<char> buffer,
                                 int* length, int* decimal_point) {
-        ASSERT(-128 <= exponent && exponent <= 0);
+        DCHECK_LE(-128, exponent);
+        DCHECK_LE(exponent, 0);
         // 'fractionals' is a fixed-point number, with binary point at bit
         // (-exponent). Inside the function the non-converted remainder of fractionals
         // is a fixed-point number, with binary point at bit 'point'.
         if (-exponent <= 64) {
             // One 64 bit number is sufficient.
             ASSERT(fractionals >> 56 == 0);
             int point = -exponent;
             for (int i = 0; i < fractional_count; ++i) {
                 if (fractionals == 0) break;
                 // Instead of multiplying by 10 we multiply by 5 and adjust the point
@@ skipping 11 matching lines @@
                 char digit = static_cast<char>(fractionals >> point);
                 buffer[*length] = '0' + digit;
                 (*length)++;
                 fractionals -= static_cast<uint64_t>(digit) << point;
             }
             // If the first bit after the point is set we have to round up.
             if (((fractionals >> (point - 1)) & 1) == 1) {
                 RoundUp(buffer, length, decimal_point);
             }
         } else {  // We need 128 bits.
-            ASSERT(64 < -exponent && -exponent <= 128);
+            DCHECK_LT(64, -exponent);
+            DCHECK_LE(-exponent, 128);
             UInt128 fractionals128 = UInt128(fractionals, 0);
             fractionals128.Shift(-exponent - 64);
             int point = 128;
             for (int i = 0; i < fractional_count; ++i) {
                 if (fractionals128.IsZero()) break;
                 // As before: instead of multiplying by 10 we multiply by 5 and adjust the
                 // point location.
                 // This multiplication will not overflow for the same reasons as before.
                 fractionals128.Multiply(5);
                 point--;
                 char digit = static_cast<char>(fractionals128.DivModPowerOf2(point));
                 buffer[*length] = '0' + digit;
                 (*length)++;
+

[tkent, 2017/05/08 14:31:04]

This change is unnecessary.

[Hwanseung Lee, 2017/05/08 23:31:13]

Done.

             }
             if (fractionals128.BitAt(point - 1) == 1) {
                 RoundUp(buffer, length, decimal_point);
             }
         }
     }
 
 
     // Removes leading and trailing zeros.
     // If leading zeros are removed then the decimal point position is adjusted.
@@ skipping 84 matching lines @@
                 FillDigits64(integrals, buffer, length);
             } else {
                 FillDigits32(static_cast<uint32_t>(integrals), buffer, length);
             }
             *decimal_point = *length;
             FillFractionals(fractionals, exponent, fractional_count,
                             buffer, length, decimal_point);
         } else if (exponent < -128) {
             // This configuration (with at most 20 digits) means that all digits must be
             // 0.
-            ASSERT(fractional_count <= 20);
+            DCHECK_LE(fractional_count, 20);
             buffer[0] = '\0';
             *length = 0;
             *decimal_point = -fractional_count;
         } else {
             *decimal_point = 0;
             FillFractionals(significand, exponent, fractional_count,
                             buffer, length, decimal_point);
         }
         TrimZeros(buffer, length, decimal_point);
         buffer[*length] = '\0';
         if ((*length) == 0) {
             // The string is empty and the decimal_point thus has no importance. Mimick
             // Gay's dtoa and and set it to -fractional_count.
             *decimal_point = -fractional_count;
         }
         return true;
     }
 
 }  // namespace double_conversion
 
 } // namespace WTF