Replace ASSERT, ENABLE(ASSERT), and ASSERT_NOT_REACHED in wtf

third_party/WebKit/Source/wtf/dtoa/double.h

 // 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 42 matching lines @@
   static const int kSignificandSize = 53;
 
   Double() : d64_(0) {}
   explicit Double(double d) : d64_(double_to_uint64(d)) {}
   explicit Double(uint64_t d64) : d64_(d64) {}
   explicit Double(DiyFp diy_fp) : d64_(DiyFpToUint64(diy_fp)) {}
 
   // The value encoded by this Double must be greater or equal to +0.0.
   // It must not be special (infinity, or NaN).
   DiyFp AsDiyFp() const {
-    ASSERT(Sign() > 0);
-    ASSERT(!IsSpecial());
+    DCHECK_GT(Sign(), 0);
+    DCHECK(!IsSpecial());
     return DiyFp(Significand(), Exponent());
   }
 
   // The value encoded by this Double must be strictly greater than 0.
   DiyFp AsNormalizedDiyFp() const {
-    ASSERT(value() > 0.0);
+    DCHECK_GT(value(), 0.0);
     uint64_t f = Significand();
     int e = Exponent();
 
     // The current double could be a denormal.
     while ((f & kHiddenBit) == 0) {
       f <<= 1;
       e--;
     }
     // Do the final shifts in one go.
     f <<= DiyFp::kSignificandSize - kSignificandSize;
@@ skipping 65 matching lines @@
   }
 
   int Sign() const {
     uint64_t d64 = AsUint64();
     return (d64 & kSignMask) == 0 ? 1 : -1;
   }
 
   // Precondition: the value encoded by this Double must be greater or equal
   // than +0.0.
   DiyFp UpperBoundary() const {
-    ASSERT(Sign() > 0);
+    DCHECK_GT(Sign(), 0);
     return DiyFp(Significand() * 2 + 1, Exponent() - 1);
   }
 
   // Computes the two boundaries of this.
   // The bigger boundary (m_plus) is normalized. The lower boundary has the same
   // exponent as m_plus.
   // Precondition: the value encoded by this Double must be greater than 0.
   void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const {
-    ASSERT(value() > 0.0);
+    DCHECK_GT(value(), 0.0);
     DiyFp v = this->AsDiyFp();
     bool significand_is_zero = (v.f() == kHiddenBit);
     DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1));
     DiyFp m_minus;
     if (significand_is_zero && v.e() != kDenormalExponent) {
       // The boundary is closer. Think of v = 1000e10 and v- = 9999e9.
       // Then the boundary (== (v - v-)/2) is not just at a distance of 1e9 but
       // at a distance of 1e8.
       // The only exception is for the smallest normal: the largest denormal is
       // at the same distance as its successor.
@@ skipping 64 matching lines @@
     return (significand & kSignificandMask) |
            (biased_exponent << kPhysicalSignificandSize);
   }
 };
 
 }  // namespace double_conversion
 
 }  // namespace WTF
 
 #endif  // DOUBLE_CONVERSION_DOUBLE_H_