[runtime] Specifically handle robust RUNTIME_ASSERTs.

src/runtime/runtime-i18n.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 #ifdef V8_I18N_SUPPORT
 #include "src/runtime/runtime-utils.h"
 
 #include "src/api.h"
 #include "src/api-natives.h"
@@ skipping 155 matching lines @@
   HandleScope scope(isolate);
   Factory* factory = isolate->factory();
 
   DCHECK(args.length() == 1);
 
   CONVERT_ARG_HANDLE_CHECKED(JSArray, input, 0);
 
   uint32_t length = static_cast<uint32_t>(input->length()->Number());
   // Set some limit to prevent fuzz tests from going OOM.
   // Can be bumped when callers' requirements change.
-  RUNTIME_ASSERT(length < 100);
+  if (length >= 100) return isolate->ThrowIllegalOperation();
   Handle<FixedArray> output = factory->NewFixedArray(length);
   Handle<Name> maximized = factory->NewStringFromStaticChars("maximized");
   Handle<Name> base = factory->NewStringFromStaticChars("base");
   for (unsigned int i = 0; i < length; ++i) {
     Handle<Object> locale_id;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, locale_id, JSReceiver::GetElement(isolate, input, i));
     if (!locale_id->IsString()) {
       return isolate->Throw(*factory->illegal_argument_string());
     }
@@ skipping 409 matching lines @@
       {"nfc", UNORM2_COMPOSE},
       {"nfc", UNORM2_DECOMPOSE},
       {"nfkc", UNORM2_COMPOSE},
       {"nfkc", UNORM2_DECOMPOSE},
   };
 
   DCHECK(args.length() == 2);
 
   CONVERT_ARG_HANDLE_CHECKED(String, s, 0);
   CONVERT_NUMBER_CHECKED(int, form_id, Int32, args[1]);
-  RUNTIME_ASSERT(form_id >= 0 &&
-                 static_cast<size_t>(form_id) < arraysize(normalizationForms));
+  CHECK(form_id >= 0 &&
+        static_cast<size_t>(form_id) < arraysize(normalizationForms));
 
   int length = s->length();
   s = String::Flatten(s);
   icu::UnicodeString result;
   base::SmartArrayPointer<uc16> sap;
   UErrorCode status = U_ZERO_ERROR;
   {
     DisallowHeapAllocation no_gc;
     String::FlatContent flat = s->GetFlatContent();
     const UChar* src = GetUCharBufferFromFlat(flat, &sap, length);
     icu::UnicodeString input(false, src, length);
     // Getting a singleton. Should not free it.
     const icu::Normalizer2* normalizer =
         icu::Normalizer2::getInstance(nullptr, normalizationForms[form_id].name,
                                       normalizationForms[form_id].mode, status);
     DCHECK(U_SUCCESS(status));
-    RUNTIME_ASSERT(normalizer != nullptr);
+    CHECK(normalizer != nullptr);
     int32_t normalized_prefix_length =
         normalizer->spanQuickCheckYes(input, status);
     // Quick return if the input is already normalized.
     if (length == normalized_prefix_length) return *s;
     icu::UnicodeString unnormalized =
         input.tempSubString(normalized_prefix_length);
     // Read-only alias of the normalized prefix.
     result.setTo(false, input.getBuffer(), normalized_prefix_length);
     // copy-on-write; normalize the suffix and append to |result|.
     normalizer->normalizeSecondAndAppend(result, unnormalized, status);
@@ skipping 510 matching lines @@
   Handle<FixedArray> date_cache_version =
       Handle<FixedArray>::cast(isolate->eternal_handles()->GetSingleton(
           EternalHandles::DATE_CACHE_VERSION));
   return date_cache_version->get(0);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_I18N_SUPPORT