Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/text

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

 /*
  * Copyright (C) 2006 Lars Knoll <lars@trolltech.com>
  * Copyright (C) 2007, 2011, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 65 matching lines @@
             icu::Locale(CurrentTextBreakLocaleID()), open_status);
       }
 
       if (U_FAILURE(open_status)) {
         DLOG(ERROR) << "icu::BreakIterator construction failed with status "
                     << open_status;
         return 0;
       }
     }
 
-    ASSERT(!vended_iterators_.Contains(iterator));
+    DCHECK(!vended_iterators_.Contains(iterator));
     vended_iterators_.Set(iterator, locale);
     return iterator;
   }
 
   void Put(icu::BreakIterator* iterator) {
     DCHECK(vended_iterators_.Contains(iterator));
 
     if (pool_.size() == kCapacity) {
       delete (pool_[0].second);
       pool_.erase(0);
@@ skipping 72 matching lines @@
   void* extra_new = destination->pExtra;
   int32_t flags = destination->flags;
   int size_to_copy = std::min(source->sizeOfStruct, destination->sizeOfStruct);
   memcpy(destination, source, size_to_copy);
   destination->pExtra = extra_new;
   destination->flags = flags;
   memcpy(destination->pExtra, source->pExtra, extra_size);
   TextFixPointer(source, destination, destination->context);
   TextFixPointer(source, destination, destination->p);
   TextFixPointer(source, destination, destination->q);
-  ASSERT(!destination->r);
+  DCHECK(!destination->r);
   const void* chunk_contents =
       static_cast<const void*>(destination->chunkContents);
   TextFixPointer(source, destination, chunk_contents);
   destination->chunkContents = static_cast<const UChar*>(chunk_contents);
   return destination;
 }
 
 static int32_t TextExtract(UText*,
                            int64_t,
                            int64_t,
                            UChar*,
                            int32_t,
                            UErrorCode* error_code) {
   // In the present context, this text provider is used only with ICU functions
   // that do not perform an extract operation.
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   *error_code = U_UNSUPPORTED_ERROR;
   return 0;
 }
 
 static void TextClose(UText* text) {
   text->context = 0;
 }
 
 static inline TextContext TextGetContext(const UText* text,
                                          int64_t native_index,
                                          UBool forward) {
   if (!text->b || native_index > text->b)
     return kPrimaryContext;
   if (native_index == text->b)
     return forward ? kPrimaryContext : kPriorContext;
   return kPriorContext;
 }
 
 static inline TextContext TextLatin1GetCurrentContext(const UText* text) {
   if (!text->chunkContents)
     return kNoContext;
   return text->chunkContents == text->pExtra ? kPrimaryContext : kPriorContext;
 }
 
 static void TextLatin1MoveInPrimaryContext(UText* text,
                                            int64_t native_index,
                                            int64_t native_length,
                                            UBool forward) {
-  ASSERT(text->chunkContents == text->pExtra);
+  DCHECK_EQ(text->chunkContents, text->pExtra);
   if (forward) {
-    ASSERT(native_index >= text->b && native_index < native_length);
+    DCHECK_GE(native_index, text->b);
+    DCHECK_LT(native_index, native_length);
     text->chunkNativeStart = native_index;
     text->chunkNativeLimit = native_index + text->extraSize / sizeof(UChar);
     if (text->chunkNativeLimit > native_length)
       text->chunkNativeLimit = native_length;
   } else {
-    ASSERT(native_index > text->b && native_index <= native_length);
+    DCHECK_GT(native_index, text->b);
+    DCHECK_LE(native_index, native_length);
     text->chunkNativeLimit = native_index;
     text->chunkNativeStart = native_index - text->extraSize / sizeof(UChar);
     if (text->chunkNativeStart < text->b)
       text->chunkNativeStart = text->b;
   }
   int64_t length = text->chunkNativeLimit - text->chunkNativeStart;
   // Ensure chunk length is well defined if computed length exceeds int32_t
   // range.
-  ASSERT(length <= std::numeric_limits<int32_t>::max());
+  DCHECK_LE(length, std::numeric_limits<int32_t>::max());
   text->chunkLength = length <= std::numeric_limits<int32_t>::max()
                           ? static_cast<int32_t>(length)
                           : 0;
   text->nativeIndexingLimit = text->chunkLength;
   text->chunkOffset = forward ? 0 : text->chunkLength;
   StringImpl::CopyChars(
       const_cast<UChar*>(text->chunkContents),
       static_cast<const LChar*>(text->p) + (text->chunkNativeStart - text->b),
       static_cast<unsigned>(text->chunkLength));
 }
 
 static void TextLatin1SwitchToPrimaryContext(UText* text,
                                              int64_t native_index,
                                              int64_t native_length,
                                              UBool forward) {
-  ASSERT(!text->chunkContents || text->chunkContents == text->q);
+  DCHECK(!text->chunkContents || text->chunkContents == text->q);
   text->chunkContents = static_cast<const UChar*>(text->pExtra);
   TextLatin1MoveInPrimaryContext(text, native_index, native_length, forward);
 }
 
 static void TextLatin1MoveInPriorContext(UText* text,
                                          int64_t native_index,
                                          int64_t native_length,
                                          UBool forward) {
-  ASSERT(text->chunkContents == text->q);
-  ASSERT(forward ? native_index < text->b : native_index <= text->b);
+  DCHECK_EQ(text->chunkContents, text->q);
+  DCHECK(forward ? native_index < text->b : native_index <= text->b);
   DCHECK(forward ? native_index < native_length
                  : native_index <= native_length);
   DCHECK(forward ? native_index < native_length
                  : native_index <= native_length);
   text->chunkNativeStart = 0;
   text->chunkNativeLimit = text->b;
   text->chunkLength = text->b;
   text->nativeIndexingLimit = text->chunkLength;
   int64_t offset = native_index - text->chunkNativeStart;
   // Ensure chunk offset is well defined if computed offset exceeds int32_t
   // range or chunk length.
-  ASSERT(offset <= std::numeric_limits<int32_t>::max());
+  DCHECK_LE(offset, std::numeric_limits<int32_t>::max());
   text->chunkOffset = std::min(offset <= std::numeric_limits<int32_t>::max()
                                    ? static_cast<int32_t>(offset)
                                    : 0,
                                text->chunkLength);
 }
 
 static void TextLatin1SwitchToPriorContext(UText* text,
                                            int64_t native_index,
                                            int64_t native_length,
                                            UBool forward) {
-  ASSERT(!text->chunkContents || text->chunkContents == text->pExtra);
+  DCHECK(!text->chunkContents || text->chunkContents == text->pExtra);
   text->chunkContents = static_cast<const UChar*>(text->q);
   TextLatin1MoveInPriorContext(text, native_index, native_length, forward);
 }
 
 static inline bool TextInChunkOrOutOfRange(UText* text,
                                            int64_t native_index,
                                            int64_t native_length,
                                            UBool forward,
                                            UBool& is_accessible) {
   if (forward) {
     if (native_index >= text->chunkNativeStart &&
         native_index < text->chunkNativeLimit) {
       int64_t offset = native_index - text->chunkNativeStart;
       // Ensure chunk offset is well formed if computed offset exceeds int32_t
       // range.
-      ASSERT(offset <= std::numeric_limits<int32_t>::max());
+      DCHECK_LE(offset, std::numeric_limits<int32_t>::max());
       text->chunkOffset = offset <= std::numeric_limits<int32_t>::max()
                               ? static_cast<int32_t>(offset)
                               : 0;
       is_accessible = TRUE;
       return true;
     }
     if (native_index >= native_length &&
         text->chunkNativeLimit == native_length) {
       text->chunkOffset = text->chunkLength;
       is_accessible = FALSE;
       return true;
     }
   } else {
     if (native_index > text->chunkNativeStart &&
         native_index <= text->chunkNativeLimit) {
       int64_t offset = native_index - text->chunkNativeStart;
       // Ensure chunk offset is well formed if computed offset exceeds int32_t
       // range.
-      ASSERT(offset <= std::numeric_limits<int32_t>::max());
+      DCHECK_LE(offset, std::numeric_limits<int32_t>::max());
       text->chunkOffset = offset <= std::numeric_limits<int32_t>::max()
                               ? static_cast<int32_t>(offset)
                               : 0;
       is_accessible = TRUE;
       return true;
     }
     if (native_index <= 0 && !text->chunkNativeStart) {
       text->chunkOffset = 0;
       is_accessible = FALSE;
       return true;
     }
   }
   return false;
 }
 
 static UBool TextLatin1Access(UText* text,
                               int64_t native_index,
                               UBool forward) {
   if (!text->context)
     return FALSE;
   int64_t native_length = TextNativeLength(text);
   UBool is_accessible;
   if (TextInChunkOrOutOfRange(text, native_index, native_length, forward,
                               is_accessible))
     return is_accessible;
   native_index = TextPinIndex(native_index, native_length - 1);
   TextContext current_context = TextLatin1GetCurrentContext(text);
   TextContext new_context = TextGetContext(text, native_index, forward);
-  ASSERT(new_context != kNoContext);
+  DCHECK_NE(new_context, kNoContext);
   if (new_context == current_context) {
     if (current_context == kPrimaryContext) {
       TextLatin1MoveInPrimaryContext(text, native_index, native_length,
                                      forward);
     } else {
       TextLatin1MoveInPriorContext(text, native_index, native_length, forward);
     }
   } else if (new_context == kPrimaryContext) {
     TextLatin1SwitchToPrimaryContext(text, native_index, native_length,
                                      forward);
   } else {
-    ASSERT(new_context == kPriorContext);
+    DCHECK_EQ(new_context, kPriorContext);
     TextLatin1SwitchToPriorContext(text, native_index, native_length, forward);
   }
   return TRUE;
 }
 
 static const struct UTextFuncs kTextLatin1Funcs = {
     sizeof(UTextFuncs), 0,           0, 0, TextClone, TextNativeLength,
     TextLatin1Access,   TextExtract, 0, 0, 0,         0,
     TextClose,          0,           0, 0,
 };
@@ skipping 23 matching lines @@
     return 0;
 
   if (!string ||
       length > static_cast<unsigned>(std::numeric_limits<int32_t>::max())) {
     *status = U_ILLEGAL_ARGUMENT_ERROR;
     return 0;
   }
   UText* text = utext_setup(&ut_with_buffer->text,
                             sizeof(ut_with_buffer->buffer), status);
   if (U_FAILURE(*status)) {
-    ASSERT(!text);
+    DCHECK(!text);
     return 0;
   }
   TextInit(text, &kTextLatin1Funcs, string, length, prior_context,
            prior_context_length);
   return text;
 }
 
 static inline TextContext TextUTF16GetCurrentContext(const UText* text) {
   if (!text->chunkContents)
     return kNoContext;
   return text->chunkContents == text->p ? kPrimaryContext : kPriorContext;
 }
 
 static void TextUTF16MoveInPrimaryContext(UText* text,
                                           int64_t native_index,
                                           int64_t native_length,
                                           UBool forward) {
-  ASSERT(text->chunkContents == text->p);
+  DCHECK_EQ(text->chunkContents, text->p);
   DCHECK(forward ? native_index >= text->b : native_index > text->b);
   DCHECK(forward ? native_index < native_length
                  : native_index <= native_length);
   text->chunkNativeStart = text->b;
   text->chunkNativeLimit = native_length;
   int64_t length = text->chunkNativeLimit - text->chunkNativeStart;
   // Ensure chunk length is well defined if computed length exceeds int32_t
   // range.
-  ASSERT(length <= std::numeric_limits<int32_t>::max());
+  DCHECK_LE(length, std::numeric_limits<int32_t>::max());
   text->chunkLength = length <= std::numeric_limits<int32_t>::max()
                           ? static_cast<int32_t>(length)
                           : 0;
   text->nativeIndexingLimit = text->chunkLength;
   int64_t offset = native_index - text->chunkNativeStart;
   // Ensure chunk offset is well defined if computed offset exceeds int32_t
   // range or chunk length.
-  ASSERT(offset <= std::numeric_limits<int32_t>::max());
+  DCHECK_LE(offset, std::numeric_limits<int32_t>::max());
   text->chunkOffset = std::min(offset <= std::numeric_limits<int32_t>::max()
                                    ? static_cast<int32_t>(offset)
                                    : 0,
                                text->chunkLength);
 }
 
 static void TextUTF16SwitchToPrimaryContext(UText* text,
                                             int64_t native_index,
                                             int64_t native_length,
                                             UBool forward) {
-  ASSERT(!text->chunkContents || text->chunkContents == text->q);
+  DCHECK(!text->chunkContents || text->chunkContents == text->q);
   text->chunkContents = static_cast<const UChar*>(text->p);
   TextUTF16MoveInPrimaryContext(text, native_index, native_length, forward);
 }
 
 static void TextUTF16MoveInPriorContext(UText* text,
                                         int64_t native_index,
                                         int64_t native_length,
                                         UBool forward) {
-  ASSERT(text->chunkContents == text->q);
-  ASSERT(forward ? native_index < text->b : native_index <= text->b);
+  DCHECK_EQ(text->chunkContents, text->q);
+  DCHECK(forward ? native_index < text->b : native_index <= text->b);
   DCHECK(forward ? native_index < native_length
                  : native_index <= native_length);
   DCHECK(forward ? native_index < native_length
                  : native_index <= native_length);
   text->chunkNativeStart = 0;
   text->chunkNativeLimit = text->b;
   text->chunkLength = text->b;
   text->nativeIndexingLimit = text->chunkLength;
   int64_t offset = native_index - text->chunkNativeStart;
   // Ensure chunk offset is well defined if computed offset exceeds int32_t
   // range or chunk length.
-  ASSERT(offset <= std::numeric_limits<int32_t>::max());
+  DCHECK_LE(offset, std::numeric_limits<int32_t>::max());
   text->chunkOffset = std::min(offset <= std::numeric_limits<int32_t>::max()
                                    ? static_cast<int32_t>(offset)
                                    : 0,
                                text->chunkLength);
 }
 
 static void TextUTF16SwitchToPriorContext(UText* text,
                                           int64_t native_index,
                                           int64_t native_length,
                                           UBool forward) {
-  ASSERT(!text->chunkContents || text->chunkContents == text->p);
+  DCHECK(!text->chunkContents || text->chunkContents == text->p);
   text->chunkContents = static_cast<const UChar*>(text->q);
   TextUTF16MoveInPriorContext(text, native_index, native_length, forward);
 }
 
 static UBool TextUTF16Access(UText* text, int64_t native_index, UBool forward) {
   if (!text->context)
     return FALSE;
   int64_t native_length = TextNativeLength(text);
   UBool is_accessible;
   if (TextInChunkOrOutOfRange(text, native_index, native_length, forward,
                               is_accessible))
     return is_accessible;
   native_index = TextPinIndex(native_index, native_length - 1);
   TextContext current_context = TextUTF16GetCurrentContext(text);
   TextContext new_context = TextGetContext(text, native_index, forward);
-  ASSERT(new_context != kNoContext);
+  DCHECK_NE(new_context, kNoContext);
   if (new_context == current_context) {
     if (current_context == kPrimaryContext) {
       TextUTF16MoveInPrimaryContext(text, native_index, native_length, forward);
     } else {
       TextUTF16MoveInPriorContext(text, native_index, native_length, forward);
     }
   } else if (new_context == kPrimaryContext) {
     TextUTF16SwitchToPrimaryContext(text, native_index, native_length, forward);
   } else {
-    ASSERT(new_context == kPriorContext);
+    DCHECK_EQ(new_context, kPriorContext);
     TextUTF16SwitchToPriorContext(text, native_index, native_length, forward);
   }
   return TRUE;
 }
 
 static const struct UTextFuncs kTextUTF16Funcs = {
     sizeof(UTextFuncs), 0,           0, 0, TextClone, TextNativeLength,
     TextUTF16Access,    TextExtract, 0, 0, 0,         0,
     TextClose,          0,           0, 0,
 };
 
 static UText* TextOpenUTF16(UText* text,
                             const UChar* string,
                             unsigned length,
                             const UChar* prior_context,
                             int prior_context_length,
                             UErrorCode* status) {
   if (U_FAILURE(*status))
     return 0;
 
   if (!string ||
       length > static_cast<unsigned>(std::numeric_limits<int32_t>::max())) {
     *status = U_ILLEGAL_ARGUMENT_ERROR;
     return 0;
   }
 
   text = utext_setup(text, 0, status);
   if (U_FAILURE(*status)) {
-    ASSERT(!text);
+    DCHECK(!text);
     return 0;
   }
   TextInit(text, &kTextUTF16Funcs, string, length, prior_context,
            prior_context_length);
   return text;
 }
 
 static UText g_empty_text = UTEXT_INITIALIZER;
 
 static TextBreakIterator* WordBreakIterator(const LChar* string, int length) {
@@ skipping 383 matching lines @@
       "$Tel1 $TelV $Tel0;"  // Telugu Virama (backward)
       "$Kan1 $KanV $Kan0;"  // Kannada Virama (backward)
       "$Mal1 $MalV $Mal0;"  // Malayalam Virama (backward)
       "!!safe_reverse;"
       "!!safe_forward;";
 
   return SetUpIteratorWithRules(kRules, string, length);
 }
 
 }  // namespace blink