Replace ASSERT with DHCECK_op in platform/wtf

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

Index: third_party/WebKit/Source/platform/wtf/dtoa/fixed-dtoa.cc
diff --git a/third_party/WebKit/Source/platform/wtf/dtoa/fixed-dtoa.cc b/third_party/WebKit/Source/platform/wtf/dtoa/fixed-dtoa.cc
index f01d3d9a93251882e7c007bce3251d9fd2e71df4..e8f9d11ed03777b5ae1a018584db50dea28e2fc4 100644
--- a/third_party/WebKit/Source/platform/wtf/dtoa/fixed-dtoa.cc
+++ b/third_party/WebKit/Source/platform/wtf/dtoa/fixed-dtoa.cc
@@ -55,11 +55,12 @@ namespace double_conversion {
             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) {
@@ -232,7 +233,8 @@ namespace double_conversion {
     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'.
@@ -264,7 +266,8 @@ namespace double_conversion {
                 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;
@@ -278,6 +281,7 @@ namespace double_conversion {
                 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);
@@ -382,7 +386,7 @@ namespace double_conversion {
         } 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;