Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/text

third_party/WebKit/Source/platform/text/StringTruncator.cpp

 /*
  * Copyright (C) 2005, 2006, 2007 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 47 matching lines @@
     int offset,
     int length) {
   int result = it.Following(offset);
   return result == kTextBreakDone ? length : result;
 }
 
 static unsigned CenterTruncateToBuffer(const String& string,
                                        unsigned length,
                                        unsigned keep_count,
                                        UChar* buffer) {
-  ASSERT(keep_count < length);
-  ASSERT(keep_count < STRING_BUFFER_SIZE);
+  DCHECK_LT(keep_count, length);
+  DCHECK(keep_count < STRING_BUFFER_SIZE);
 
   unsigned omit_start = (keep_count + 1) / 2;
   NonSharedCharacterBreakIterator it(string);
   unsigned omit_end = BoundedTextBreakFollowing(
       it, omit_start + (length - keep_count) - 1, length);
   omit_start = TextBreakAtOrPreceding(it, omit_start);
 
   unsigned truncated_length = omit_start + 1 + (length - omit_end);
-  ASSERT(truncated_length <= length);
+  DCHECK_LE(truncated_length, length);
 
   string.CopyTo(buffer, 0, omit_start);
   buffer[omit_start] = kHorizontalEllipsisCharacter;
   string.CopyTo(&buffer[omit_start + 1], omit_end, length - omit_end);
 
   return truncated_length;
 }
 
 static unsigned RightTruncateToBuffer(const String& string,
                                       unsigned length,
                                       unsigned keep_count,
                                       UChar* buffer) {
-  ASSERT(keep_count < length);
-  ASSERT(keep_count < STRING_BUFFER_SIZE);
+  DCHECK_LT(keep_count, length);
+  DCHECK(keep_count < STRING_BUFFER_SIZE);
 
   NonSharedCharacterBreakIterator it(string);
   unsigned keep_length = TextBreakAtOrPreceding(it, keep_count);
   unsigned truncated_length = keep_length + 1;
 
   string.CopyTo(buffer, 0, keep_length);
   buffer[keep_length] = kHorizontalEllipsisCharacter;
 
   return truncated_length;
 }
@@ skipping 10 matching lines @@
   return renderer.Width(run);
 }
 
 static String TruncateString(const String& string,
                              float max_width,
                              const Font& font,
                              TruncationFunction truncate_to_buffer) {
   if (string.IsEmpty())
     return string;
 
-  ASSERT(max_width >= 0);
+  DCHECK_GE(max_width, 0);
 
   float current_ellipsis_width =
       StringWidth(font, &kHorizontalEllipsisCharacter, 1);
 
   UChar string_buffer[STRING_BUFFER_SIZE];
   unsigned truncated_length;
   unsigned keep_count;
   unsigned length = string.length();
 
   if (length > STRING_BUFFER_SIZE) {
@@ skipping 16 matching lines @@
   unsigned keep_count_for_smallest_known_to_not_fit = keep_count;
   float width_for_smallest_known_to_not_fit = width;
 
   if (current_ellipsis_width >= max_width) {
     keep_count_for_largest_known_to_fit = 1;
     keep_count_for_smallest_known_to_not_fit = 2;
   }
 
   while (keep_count_for_largest_known_to_fit + 1 <
          keep_count_for_smallest_known_to_not_fit) {
-    ASSERT(width_for_largest_known_to_fit <= max_width);
-    ASSERT(width_for_smallest_known_to_not_fit > max_width);
+    DCHECK_LE(width_for_largest_known_to_fit, max_width);
+    DCHECK_GT(width_for_smallest_known_to_not_fit, max_width);
 
     float ratio =
         (keep_count_for_smallest_known_to_not_fit -
          keep_count_for_largest_known_to_fit) /
         (width_for_smallest_known_to_not_fit - width_for_largest_known_to_fit);
     keep_count = static_cast<unsigned>(max_width * ratio);
 
     if (keep_count <= keep_count_for_largest_known_to_fit) {
       keep_count = keep_count_for_largest_known_to_fit + 1;
     } else if (keep_count >= keep_count_for_smallest_known_to_not_fit) {
       keep_count = keep_count_for_smallest_known_to_not_fit - 1;
     }
 
-    ASSERT(keep_count < length);
-    ASSERT(keep_count > 0);
-    ASSERT(keep_count < keep_count_for_smallest_known_to_not_fit);
-    ASSERT(keep_count > keep_count_for_largest_known_to_fit);
+    DCHECK_LT(keep_count, length);
+    DCHECK_GT(keep_count, 0u);
+    DCHECK_LT(keep_count, keep_count_for_smallest_known_to_not_fit);
+    DCHECK_GT(keep_count, keep_count_for_largest_known_to_fit);
 
     truncated_length =
         truncate_to_buffer(string, length, keep_count, string_buffer);
 
     width = StringWidth(font, string_buffer, truncated_length);
     if (width <= max_width) {
       keep_count_for_largest_known_to_fit = keep_count;
       width_for_largest_known_to_fit = width;
     } else {
       keep_count_for_smallest_known_to_not_fit = keep_count;
@@ skipping 23 matching lines @@
                                       float max_width,
                                       const Font& font) {
   return TruncateString(string, max_width, font, RightTruncateToBuffer);
 }
 
 float StringTruncator::Width(const String& string, const Font& font) {
   return StringWidth(font, string);
 }
 
 }  // namespace blink