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()), openStatus);
       }
 
       if (U_FAILURE(openStatus)) {
         DLOG(ERROR) << "icu::BreakIterator construction failed with status "
                     << openStatus;
         return 0;
       }
     }
 
-    ASSERT(!m_vendedIterators.contains(iterator));
+    DCHECK(!m_vendedIterators.contains(iterator));
     m_vendedIterators.set(iterator, locale);
     return iterator;
   }
 
   void put(icu::BreakIterator* iterator) {
     DCHECK(m_vendedIterators.contains(iterator));
 
     if (m_pool.size() == capacity) {
       delete (m_pool[0].second);
       m_pool.erase(0);
@@ skipping 72 matching lines @@
   void* extraNew = destination->pExtra;
   int32_t flags = destination->flags;
   int sizeToCopy = std::min(source->sizeOfStruct, destination->sizeOfStruct);
   memcpy(destination, source, sizeToCopy);
   destination->pExtra = extraNew;
   destination->flags = flags;
   memcpy(destination->pExtra, source->pExtra, extraSize);
   textFixPointer(source, destination, destination->context);
   textFixPointer(source, destination, destination->p);
   textFixPointer(source, destination, destination->q);
-  ASSERT(!destination->r);
+  DCHECK(!destination->r);
   const void* chunkContents =
       static_cast<const void*>(destination->chunkContents);
   textFixPointer(source, destination, chunkContents);
   destination->chunkContents = static_cast<const UChar*>(chunkContents);
   return destination;
 }
 
 static int32_t textExtract(UText*,
                            int64_t,
                            int64_t,
                            UChar*,
                            int32_t,
                            UErrorCode* errorCode) {
   // In the present context, this text provider is used only with ICU functions
   // that do not perform an extract operation.
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   *errorCode = U_UNSUPPORTED_ERROR;
   return 0;
 }
 
 static void textClose(UText* text) {
   text->context = 0;
 }
 
 static inline TextContext textGetContext(const UText* text,
                                          int64_t nativeIndex,
                                          UBool forward) {
   if (!text->b || nativeIndex > text->b)
     return PrimaryContext;
   if (nativeIndex == text->b)
     return forward ? PrimaryContext : PriorContext;
   return PriorContext;
 }
 
 static inline TextContext textLatin1GetCurrentContext(const UText* text) {
   if (!text->chunkContents)
     return NoContext;
   return text->chunkContents == text->pExtra ? PrimaryContext : PriorContext;
 }
 
 static void textLatin1MoveInPrimaryContext(UText* text,
                                            int64_t nativeIndex,
                                            int64_t nativeLength,
                                            UBool forward) {
-  ASSERT(text->chunkContents == text->pExtra);
+  DCHECK_EQ(text->chunkContents, text->pExtra);
   if (forward) {
-    ASSERT(nativeIndex >= text->b && nativeIndex < nativeLength);
+    DCHECK(nativeIndex >= text->b && nativeIndex < nativeLength);

[tkent, 2017/04/09 23:07:02]

Split this into two DCHECKs.

[Hwanseung Lee, 2017/04/11 03:29:38]

Done.

     text->chunkNativeStart = nativeIndex;
     text->chunkNativeLimit = nativeIndex + text->extraSize / sizeof(UChar);
     if (text->chunkNativeLimit > nativeLength)
       text->chunkNativeLimit = nativeLength;
   } else {
-    ASSERT(nativeIndex > text->b && nativeIndex <= nativeLength);
+    DCHECK(nativeIndex > text->b && nativeIndex <= nativeLength);

[tkent, 2017/04/09 23:07:02]

Split this into two DCHECKs

[Hwanseung Lee, 2017/04/11 03:29:38]

Done.

     text->chunkNativeLimit = nativeIndex;
     text->chunkNativeStart = nativeIndex - 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 nativeIndex,
                                              int64_t nativeLength,
                                              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, nativeIndex, nativeLength, forward);
 }
 
 static void textLatin1MoveInPriorContext(UText* text,
                                          int64_t nativeIndex,
                                          int64_t nativeLength,
                                          UBool forward) {
-  ASSERT(text->chunkContents == text->q);
-  ASSERT(forward ? nativeIndex < text->b : nativeIndex <= text->b);
+  DCHECK_EQ(text->chunkContents, text->q);
+  DCHECK(forward ? nativeIndex < text->b : nativeIndex <= text->b);
   DCHECK(forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
   DCHECK(forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
   text->chunkNativeStart = 0;
   text->chunkNativeLimit = text->b;
   text->chunkLength = text->b;
   text->nativeIndexingLimit = text->chunkLength;
   int64_t offset = nativeIndex - 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 nativeIndex,
                                            int64_t nativeLength,
                                            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, nativeIndex, nativeLength, forward);
 }
 
 static inline bool textInChunkOrOutOfRange(UText* text,
                                            int64_t nativeIndex,
                                            int64_t nativeLength,
                                            UBool forward,
                                            UBool& isAccessible) {
   if (forward) {
     if (nativeIndex >= text->chunkNativeStart &&
         nativeIndex < text->chunkNativeLimit) {
       int64_t offset = nativeIndex - 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;
       isAccessible = TRUE;
       return true;
     }
     if (nativeIndex >= nativeLength && text->chunkNativeLimit == nativeLength) {
       text->chunkOffset = text->chunkLength;
       isAccessible = FALSE;
       return true;
     }
   } else {
     if (nativeIndex > text->chunkNativeStart &&
         nativeIndex <= text->chunkNativeLimit) {
       int64_t offset = nativeIndex - 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;
       isAccessible = TRUE;
       return true;
     }
     if (nativeIndex <= 0 && !text->chunkNativeStart) {
       text->chunkOffset = 0;
       isAccessible = FALSE;
       return true;
     }
   }
   return false;
 }
 
 static UBool textLatin1Access(UText* text, int64_t nativeIndex, UBool forward) {
   if (!text->context)
     return FALSE;
   int64_t nativeLength = textNativeLength(text);
   UBool isAccessible;
   if (textInChunkOrOutOfRange(text, nativeIndex, nativeLength, forward,
                               isAccessible))
     return isAccessible;
   nativeIndex = textPinIndex(nativeIndex, nativeLength - 1);
   TextContext currentContext = textLatin1GetCurrentContext(text);
   TextContext newContext = textGetContext(text, nativeIndex, forward);
-  ASSERT(newContext != NoContext);
+  DCHECK_NE(newContext, NoContext);
   if (newContext == currentContext) {
     if (currentContext == PrimaryContext) {
       textLatin1MoveInPrimaryContext(text, nativeIndex, nativeLength, forward);
     } else {
       textLatin1MoveInPriorContext(text, nativeIndex, nativeLength, forward);
     }
   } else if (newContext == PrimaryContext) {
     textLatin1SwitchToPrimaryContext(text, nativeIndex, nativeLength, forward);
   } else {
-    ASSERT(newContext == PriorContext);
+    DCHECK_EQ(newContext, PriorContext);
     textLatin1SwitchToPriorContext(text, nativeIndex, nativeLength, forward);
   }
   return TRUE;
 }
 
 static const struct UTextFuncs textLatin1Funcs = {
     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(&utWithBuffer->text, sizeof(utWithBuffer->buffer), status);
   if (U_FAILURE(*status)) {
-    ASSERT(!text);
+    DCHECK(!text);
     return 0;
   }
   textInit(text, &textLatin1Funcs, string, length, priorContext,
            priorContextLength);
   return text;
 }
 
 static inline TextContext textUTF16GetCurrentContext(const UText* text) {
   if (!text->chunkContents)
     return NoContext;
   return text->chunkContents == text->p ? PrimaryContext : PriorContext;
 }
 
 static void textUTF16MoveInPrimaryContext(UText* text,
                                           int64_t nativeIndex,
                                           int64_t nativeLength,
                                           UBool forward) {
-  ASSERT(text->chunkContents == text->p);
+  DCHECK_EQ(text->chunkContents, text->p);
   DCHECK(forward ? nativeIndex >= text->b : nativeIndex > text->b);
   DCHECK(forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
   text->chunkNativeStart = text->b;
   text->chunkNativeLimit = nativeLength;
   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 = nativeIndex - 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 nativeIndex,
                                             int64_t nativeLength,
                                             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, nativeIndex, nativeLength, forward);
 }
 
 static void textUTF16MoveInPriorContext(UText* text,
                                         int64_t nativeIndex,
                                         int64_t nativeLength,
                                         UBool forward) {
-  ASSERT(text->chunkContents == text->q);
-  ASSERT(forward ? nativeIndex < text->b : nativeIndex <= text->b);
+  DCHECK_EQ(text->chunkContents, text->q);
+  DCHECK(forward ? nativeIndex < text->b : nativeIndex <= text->b);
   DCHECK(forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
   DCHECK(forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
   text->chunkNativeStart = 0;
   text->chunkNativeLimit = text->b;
   text->chunkLength = text->b;
   text->nativeIndexingLimit = text->chunkLength;
   int64_t offset = nativeIndex - 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 nativeIndex,
                                           int64_t nativeLength,
                                           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, nativeIndex, nativeLength, forward);
 }
 
 static UBool textUTF16Access(UText* text, int64_t nativeIndex, UBool forward) {
   if (!text->context)
     return FALSE;
   int64_t nativeLength = textNativeLength(text);
   UBool isAccessible;
   if (textInChunkOrOutOfRange(text, nativeIndex, nativeLength, forward,
                               isAccessible))
     return isAccessible;
   nativeIndex = textPinIndex(nativeIndex, nativeLength - 1);
   TextContext currentContext = textUTF16GetCurrentContext(text);
   TextContext newContext = textGetContext(text, nativeIndex, forward);
-  ASSERT(newContext != NoContext);
+  DCHECK_NE(newContext, NoContext);
   if (newContext == currentContext) {
     if (currentContext == PrimaryContext) {
       textUTF16MoveInPrimaryContext(text, nativeIndex, nativeLength, forward);
     } else {
       textUTF16MoveInPriorContext(text, nativeIndex, nativeLength, forward);
     }
   } else if (newContext == PrimaryContext) {
     textUTF16SwitchToPrimaryContext(text, nativeIndex, nativeLength, forward);
   } else {
-    ASSERT(newContext == PriorContext);
+    DCHECK_EQ(newContext, PriorContext);
     textUTF16SwitchToPriorContext(text, nativeIndex, nativeLength, forward);
   }
   return TRUE;
 }
 
 static const struct UTextFuncs textUTF16Funcs = {
     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* priorContext,
                             int priorContextLength,
                             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, &textUTF16Funcs, string, length, priorContext,
            priorContextLength);
   return text;
 }
 
 static UText emptyText = UTEXT_INITIALIZER;
 
 static TextBreakIterator* wordBreakIterator(const LChar* string, int length) {
@@ skipping 387 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