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

third_party/WebKit/Source/wtf/dtoa/utils.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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef DOUBLE_CONVERSION_UTILS_H_
 #define DOUBLE_CONVERSION_UTILS_H_
 
 #include "wtf/Assertions.h"
 #include <string.h>
 
-#define UNIMPLEMENTED ASSERT_NOT_REACHED
-#define UNREACHABLE ASSERT_NOT_REACHED
+#define UNIMPLEMENTED NOTREACHED
+#define UNREACHABLE NOTREACHED
 
 // Double operations detection based on target architecture.
 // Linux uses a 80bit wide floating point stack on x86. This induces double
 // rounding, which in turn leads to wrong results.
 // An easy way to test if the floating-point operations are correct is to
 // evaluate: 89255.0/1e22. If the floating-point stack is 64 bits wide then
 // the result is equal to 89255e-22.
 // The best way to test this, is to create a division-function and to compare
 // the output of the division with the expected result. (Inlining must be
 // disabled.)
@@ skipping 74 matching lines @@
 }
 
 // Returns the minimum of the two parameters.
 template <typename T>
 static T Min(T a, T b) {
   return a < b ? a : b;
 }
 
 inline int StrLength(const char* string) {
   size_t length = strlen(string);
-  ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
+  DCHECK_EQ(length, static_cast<size_t>(static_cast<int>(length)));
   return static_cast<int>(length);
 }
 
 // This is a simplified version of V8's Vector class.
 template <typename T>
 class Vector {
  public:
   Vector() : start_(NULL), length_(0) {}
   Vector(T* data, int length) : start_(data), length_(length) {
-    ASSERT(length == 0 || (length > 0 && data != NULL));
+    DCHECK(length == 0 || (length > 0 && data != NULL));
   }
 
   // Returns a vector using the same backing storage as this one,
   // spanning from and including 'from', to but not including 'to'.
   Vector<T> SubVector(int from, int to) {
-    ASSERT(to <= length_);
-    ASSERT(from < to);
-    ASSERT(0 <= from);
+    DCHECK_LE(to, length_);
+    DCHECK_LT(from, to);
+    DCHECK_LE(0, from);
     return Vector<T>(start() + from, to - from);
   }
 
   // Returns the length of the vector.
   int length() const { return length_; }
 
   // Returns whether or not the vector is empty.
   bool is_empty() const { return length_ == 0; }
 
   // Returns the pointer to the start of the data in the vector.
@@ skipping 23 matching lines @@
 
   ~StringBuilder() {
     if (!is_finalized())
       Finalize();
   }
 
   int size() const { return buffer_.length(); }
 
   // Get the current position in the builder.
   int position() const {
-    ASSERT(!is_finalized());
+    DCHECK(!is_finalized());
     return position_;
   }
 
   // Set the current position in the builder.
   void SetPosition(int position) {
-    ASSERT(!is_finalized());
+    DCHECK(!is_finalized());
     SECURITY_DCHECK(position < size());
     position_ = position;
   }
 
   // Reset the position.
   void Reset() { position_ = 0; }
 
   // Add a single character to the builder. It is not allowed to add
   // 0-characters; use the Finalize() method to terminate the string
   // instead.
   void AddCharacter(char c) {
-    ASSERT(c != '\0');
-    ASSERT(!is_finalized() && position_ < buffer_.length());
+    DCHECK_NE(c, '\0');
+    DCHECK(!is_finalized());
+    DCHECK_LT(position_, buffer_.length());
     buffer_[position_++] = c;
   }
 
   // Add an entire string to the builder. Uses strlen() internally to
   // compute the length of the input string.
   void AddString(const char* s) { AddSubstring(s, StrLength(s)); }
 
   // Add the first 'n' characters of the given string 's' to the
   // builder. The input string must have enough characters.
   void AddSubstring(const char* s, int n) {
-    ASSERT(!is_finalized() && position_ + n < buffer_.length());
+    DCHECK(!is_finalized());
+    DCHECK_LT(position_ + n, buffer_.length());
     SECURITY_DCHECK(static_cast<size_t>(n) <= strlen(s));
     memcpy(&buffer_[position_], s, n * kCharSize);
     position_ += n;
   }
 
   // Add character padding to the builder. If count is non-positive,
   // nothing is added to the builder.
   void AddPadding(char c, int count) {
     for (int i = 0; i < count; i++) {
       AddCharacter(c);
     }
   }
 
   // Finalize the string by 0-terminating it and returning the buffer.
   char* Finalize() {
-    ASSERT(!is_finalized() && position_ < buffer_.length());
+    DCHECK(!is_finalized());
+    DCHECK_LT(position_, buffer_.length());
     buffer_[position_] = '\0';
     // Make sure nobody managed to add a 0-character to the
     // buffer while building the string.
-    ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
+    DCHECK_EQ(strlen(buffer_.start()), static_cast<size_t>(position_));
     position_ = -1;
-    ASSERT(is_finalized());
+    DCHECK(is_finalized());
     return buffer_.start();
   }
 
  private:
   Vector<char> buffer_;
   int position_;
 
   bool is_finalized() const { return position_ < 0; }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
@@ skipping 37 matching lines @@
 template <class Dest, class Source>
 inline Dest BitCast(Source* source) {
   return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
 }
 
 }  // namespace double_conversion
 
 }  // namespace WTF
 
 #endif  // DOUBLE_CONVERSION_UTILS_H_