Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

third_party/WebKit/Source/bindings/core/v8/V8Binding.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Google 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:
  *
  *     * 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
@@ skipping 79 matching lines @@
   NodeFilterCondition* condition = V8NodeFilterCondition::Create(
       callback, filter_wrapper.As<v8::Object>(), script_state);
   filter->SetCondition(condition);
 
   return filter;
 }
 
 bool ToBooleanSlow(v8::Isolate* isolate,
                    v8::Local<v8::Value> value,
                    ExceptionState& exception_state) {
-  ASSERT(!value->IsBoolean());
+  DCHECK(!value->IsBoolean());
   v8::TryCatch block(isolate);
   bool result = false;
   if (!V8Call(value->BooleanValue(isolate->GetCurrentContext()), result, block))
     exception_state.RethrowV8Exception(block.Exception());
   return result;
 }
 
 const int32_t kMaxInt32 = 0x7fffffff;
 const int32_t kMinInt32 = -kMaxInt32 - 1;
 const uint32_t kMaxUInt32 = 0xffffffff;
@@ skipping 81 matching lines @@
     number_object = value.As<v8::Number>();
   } else {
     // Can the value be converted to a number?
     v8::TryCatch block(isolate);
     if (!V8Call(value->ToNumber(isolate->GetCurrentContext()), number_object,
                 block)) {
       exception_state.RethrowV8Exception(block.Exception());
       return 0;
     }
   }
-  ASSERT(!number_object.IsEmpty());
+  DCHECK(!number_object.IsEmpty());
 
   if (configuration == kEnforceRange)
     return EnforceRange(number_object->Value(), LimitsTrait::kMinValue,
                         LimitsTrait::kMaxValue, type_name, exception_state);
 
   double number_value = number_object->Value();
   if (std::isnan(number_value) || !number_value)
     return 0;
 
   if (configuration == kClamp)
@@ skipping 39 matching lines @@
     number_object = value.As<v8::Number>();
   } else {
     // Can the value be converted to a number?
     v8::TryCatch block(isolate);
     if (!V8Call(value->ToNumber(isolate->GetCurrentContext()), number_object,
                 block)) {
       exception_state.RethrowV8Exception(block.Exception());
       return 0;
     }
   }
-  ASSERT(!number_object.IsEmpty());
+  DCHECK(!number_object.IsEmpty());
 
   if (configuration == kEnforceRange)
     return EnforceRange(number_object->Value(), 0, LimitsTrait::kMaxValue,
                         type_name, exception_state);
 
   double number_value = number_object->Value();
 
   if (std::isnan(number_value) || !number_value)
     return 0;
 
@@ skipping 37 matching lines @@
                   IntegerConversionConfiguration configuration,
                   ExceptionState& exception_state) {
   return ToSmallerUInt<uint16_t>(isolate, value, configuration,
                                  "unsigned short", exception_state);
 }
 
 int32_t ToInt32Slow(v8::Isolate* isolate,
                     v8::Local<v8::Value> value,
                     IntegerConversionConfiguration configuration,
                     ExceptionState& exception_state) {
-  ASSERT(!value->IsInt32());
+  DCHECK(!value->IsInt32());
   // Can the value be converted to a number?
   v8::TryCatch block(isolate);
   v8::Local<v8::Number> number_object;
   if (!V8Call(value->ToNumber(isolate->GetCurrentContext()), number_object,
               block)) {
     exception_state.RethrowV8Exception(block.Exception());
     return 0;
   }
 
-  ASSERT(!number_object.IsEmpty());
+  DCHECK(!number_object.IsEmpty());
 
   double number_value = number_object->Value();
   if (configuration == kEnforceRange)
     return EnforceRange(number_value, kMinInt32, kMaxInt32, "long",
                         exception_state);
 
   if (std::isnan(number_value))
     return 0;
 
   if (configuration == kClamp)
     return clampTo<int32_t>(number_value);
 
   if (std::isinf(number_value))
     return 0;
 
   int32_t result;
   if (!V8Call(number_object->Int32Value(isolate->GetCurrentContext()), result,
               block)) {
     exception_state.RethrowV8Exception(block.Exception());
     return 0;
   }
   return result;
 }
 
 uint32_t ToUInt32Slow(v8::Isolate* isolate,
                       v8::Local<v8::Value> value,
                       IntegerConversionConfiguration configuration,
                       ExceptionState& exception_state) {
-  ASSERT(!value->IsUint32());
+  DCHECK(!value->IsUint32());
   if (value->IsInt32()) {
-    ASSERT(configuration != kNormalConversion);
+    DCHECK_NE(configuration, kNormalConversion);
     int32_t result = value.As<v8::Int32>()->Value();
     if (result >= 0)
       return result;
     if (configuration == kEnforceRange) {
       exception_state.ThrowTypeError(
           "Value is outside the 'unsigned long' value range.");
       return 0;
     }
-    ASSERT(configuration == kClamp);
+    DCHECK_EQ(configuration, kClamp);
     return clampTo<uint32_t>(result);
   }
 
   // Can the value be converted to a number?
   v8::TryCatch block(isolate);
   v8::Local<v8::Number> number_object;
   if (!V8Call(value->ToNumber(isolate->GetCurrentContext()), number_object,
               block)) {
     exception_state.RethrowV8Exception(block.Exception());
     return 0;
   }
-  ASSERT(!number_object.IsEmpty());
+  DCHECK(!number_object.IsEmpty());
 
   if (configuration == kEnforceRange)
     return EnforceRange(number_object->Value(), 0, kMaxUInt32, "unsigned long",
                         exception_state);
 
   double number_value = number_object->Value();
 
   if (std::isnan(number_value))
     return 0;
 
   if (configuration == kClamp)
     return clampTo<uint32_t>(number_value);
 
   if (std::isinf(number_value))
     return 0;
 
   uint32_t result;
   if (!V8Call(number_object->Uint32Value(isolate->GetCurrentContext()), result,
               block)) {
     exception_state.RethrowV8Exception(block.Exception());
     return 0;
   }
   return result;
 }
 
 int64_t ToInt64Slow(v8::Isolate* isolate,
                     v8::Local<v8::Value> value,
                     IntegerConversionConfiguration configuration,
                     ExceptionState& exception_state) {
-  ASSERT(!value->IsInt32());
+  DCHECK(!value->IsInt32());
 
   v8::Local<v8::Number> number_object;
   // Can the value be converted to a number?
   v8::TryCatch block(isolate);
   if (!V8Call(value->ToNumber(isolate->GetCurrentContext()), number_object,
               block)) {
     exception_state.RethrowV8Exception(block.Exception());
     return 0;
   }
-  ASSERT(!number_object.IsEmpty());
+  DCHECK(!number_object.IsEmpty());
 
   double number_value = number_object->Value();
 
   if (configuration == kEnforceRange)
     return EnforceRange(number_value, -kJSMaxInteger, kJSMaxInteger,
                         "long long", exception_state);
 
   if (std::isnan(number_value) || std::isinf(number_value))
     return 0;
 
   // NaNs and +/-Infinity should be 0, otherwise modulo 2^64.
   unsigned long long integer;
   doubleToInteger(number_value, integer);
   return integer;
 }
 
 uint64_t ToUInt64Slow(v8::Isolate* isolate,
                       v8::Local<v8::Value> value,
                       IntegerConversionConfiguration configuration,
                       ExceptionState& exception_state) {
-  ASSERT(!value->IsUint32());
+  DCHECK(!value->IsUint32());
   if (value->IsInt32()) {
     ASSERT(configuration != kNormalConversion);
     int32_t result = value.As<v8::Int32>()->Value();
     if (result >= 0)
       return result;
     if (configuration == kEnforceRange) {
       exception_state.ThrowTypeError(
           "Value is outside the 'unsigned long long' value range.");
       return 0;
     }
-    ASSERT(configuration == kClamp);
+    DCHECK_EQ(configuration, kClamp);
     return clampTo<uint64_t>(result);
   }
 
   v8::Local<v8::Number> number_object;
   // Can the value be converted to a number?
   v8::TryCatch block(isolate);
   if (!V8Call(value->ToNumber(isolate->GetCurrentContext()), number_object,
               block)) {
     exception_state.RethrowV8Exception(block.Exception());
     return 0;
   }
-  ASSERT(!number_object.IsEmpty());
+  DCHECK(!number_object.IsEmpty());
 
   double number_value = number_object->Value();
 
   if (configuration == kEnforceRange)
     return EnforceRange(number_value, 0, kJSMaxInteger, "unsigned long long",
                         exception_state);
 
   if (std::isnan(number_value))
     return 0;
 
@@ skipping 18 matching lines @@
   if (!std::isfinite(number_value)) {
     exception_state.ThrowTypeError("The provided float value is non-finite.");
     return 0;
   }
   return number_value;
 }
 
 double ToDoubleSlow(v8::Isolate* isolate,
                     v8::Local<v8::Value> value,
                     ExceptionState& exception_state) {
-  ASSERT(!value->IsNumber());
+  DCHECK(!value->IsNumber());
   v8::TryCatch block(isolate);
   v8::Local<v8::Number> number_value;
   if (!value->ToNumber(isolate->GetCurrentContext()).ToLocal(&number_value)) {
     exception_state.RethrowV8Exception(block.Exception());
     return 0;
   }
   return number_value->Value();
 }
 
 double ToRestrictedDouble(v8::Isolate* isolate,
@@ skipping 81 matching lines @@
   // This roughly implements http://heycam.github.io/webidl/#dfn-obtain-unicode
   // but since Blink strings are 16-bits internally, the output is simply
   // re-encoded to UTF-16.
 
   // The concept of surrogate pairs is explained at:
   // http://www.unicode.org/versions/Unicode6.2.0/ch03.pdf#G2630
 
   // Blink-specific optimization to avoid making an unnecessary copy.
   if (!HasUnmatchedSurrogates(string))
     return string;
-  ASSERT(!string.Is8Bit());
+  DCHECK(!string.Is8Bit());
 
   // 1. Let S be the DOMString value.
   const UChar* s = string.Characters16();
 
   // 2. Let n be the length of S.
   const unsigned n = string.length();
 
   // 3. Initialize i to 0.
   unsigned i = 0;
 
   // 4. Initialize U to be an empty sequence of Unicode characters.
   StringBuilder u;
   u.ReserveCapacity(n);
 
   // 5. While i < n:
   while (i < n) {
     // 1. Let c be the code unit in S at index i.
     UChar c = s[i];
     // 2. Depending on the value of c:
     if (U16_IS_SINGLE(c)) {
       // c < 0xD800 or c > 0xDFFF
       // Append to U the Unicode character with code point c.
       u.Append(c);
     } else if (U16_IS_TRAIL(c)) {
       // 0xDC00 <= c <= 0xDFFF
       // Append to U a U+FFFD REPLACEMENT CHARACTER.
       u.Append(kReplacementCharacter);
     } else {
       // 0xD800 <= c <= 0xDBFF
-      ASSERT(U16_IS_LEAD(c));
+      DCHECK(U16_IS_LEAD(c));
       if (i == n - 1) {
         // 1. If i = n-1, then append to U a U+FFFD REPLACEMENT CHARACTER.
         u.Append(kReplacementCharacter);
       } else {
         // 2. Otherwise, i < n-1:
-        ASSERT(i < n - 1);
+        DCHECK_LT(i, n - 1);
         // ....1. Let d be the code unit in S at index i+1.
         UChar d = s[i + 1];
         if (U16_IS_TRAIL(d)) {
           // 2. If 0xDC00 <= d <= 0xDFFF, then:
           // ..1. Let a be c & 0x3FF.
           // ..2. Let b be d & 0x3FF.
           // ..3. Append to U the Unicode character with code point
           //      2^16+2^10*a+b.
           u.Append(U16_GET_SUPPLEMENTARY(c, d));
           // Blink: This is equivalent to u.append(c); u.append(d);
           ++i;
         } else {
           // 3. Otherwise, d < 0xDC00 or d > 0xDFFF. Append to U a U+FFFD
           //    REPLACEMENT CHARACTER.
           u.Append(kReplacementCharacter);
         }
       }
     }
     // 3. Set i to i+1.
     ++i;
   }
 
   // 6. Return U.
-  ASSERT(u.length() == string.length());
+  DCHECK_EQ(u.length(), string.length());
   return u.ToString();
 }
 
 String ToUSVString(v8::Isolate* isolate,
                    v8::Local<v8::Value> value,
                    ExceptionState& exception_state) {
   // http://heycam.github.io/webidl/#es-USVString
   if (value.IsEmpty())
     return String();
 
@@ skipping 89 matching lines @@
   // We return 0 here because |context| is detached from the Frame. If we
   // did return |frame| we could get in trouble because the frame could be
   // navigated to another security origin.
   return nullptr;
 }
 
 void ToFlexibleArrayBufferView(v8::Isolate* isolate,
                                v8::Local<v8::Value> value,
                                FlexibleArrayBufferView& result,
                                void* storage) {
-  ASSERT(value->IsArrayBufferView());
+  DCHECK(value->IsArrayBufferView());
   v8::Local<v8::ArrayBufferView> buffer = value.As<v8::ArrayBufferView>();
   if (!storage) {
     result.SetFull(V8ArrayBufferView::toImpl(buffer));
     return;
   }
   size_t length = buffer->ByteLength();
   buffer->CopyContents(storage, length);
   result.SetSmall(storage, length);
 }
 
 static ScriptState* ToScriptStateImpl(LocalFrame* frame,
                                       DOMWrapperWorld& world) {
   if (!frame)
     return nullptr;
   v8::Local<v8::Context> context = ToV8ContextEvenIfDetached(frame, world);
   if (context.IsEmpty())
     return nullptr;
   ScriptState* script_state = ScriptState::From(context);
   if (!script_state->ContextIsValid())
     return nullptr;
   DCHECK_EQ(frame, ToLocalFrameIfNotDetached(context));
   return script_state;
 }
 
 v8::Local<v8::Context> ToV8Context(ExecutionContext* context,
                                    DOMWrapperWorld& world) {
-  ASSERT(context);
+  DCHECK(context);
   if (context->IsDocument()) {
     if (LocalFrame* frame = ToDocument(context)->GetFrame())
       return ToV8Context(frame, world);
   } else if (context->IsWorkerGlobalScope()) {
     if (WorkerOrWorkletScriptController* script =
             ToWorkerOrWorkletGlobalScope(context)->ScriptController()) {
       if (script->GetScriptState()->ContextIsValid())
         return script->GetScriptState()->GetContext();
     }
   }
   return v8::Local<v8::Context>();
 }
 
 v8::Local<v8::Context> ToV8Context(LocalFrame* frame, DOMWrapperWorld& world) {
   ScriptState* script_state = ToScriptStateImpl(frame, world);
   if (!script_state)
     return v8::Local<v8::Context>();
   return script_state->GetContext();
 }
 
 v8::Local<v8::Context> ToV8ContextEvenIfDetached(LocalFrame* frame,
                                                  DOMWrapperWorld& world) {
-  ASSERT(frame);
+  DCHECK(frame);
   return frame->WindowProxy(world)->ContextIfInitialized();
 }
 
 ScriptState* ToScriptState(LocalFrame* frame, DOMWrapperWorld& world) {
   v8::HandleScope handle_scope(ToIsolate(frame));
   return ToScriptStateImpl(frame, world);
 }
 
 ScriptState* ToScriptStateForMainWorld(LocalFrame* frame) {
   return ToScriptState(frame, DOMWrapperWorld::MainWorld());
@@ skipping 63 matching lines @@
     exception_state.ThrowTypeError("Iterator is not an object.");
     return v8::Local<v8::Object>();
   }
   return iterator.As<v8::Object>();
 }
 
 bool AddHiddenValueToArray(v8::Isolate* isolate,
                            v8::Local<v8::Object> object,
                            v8::Local<v8::Value> value,
                            int array_index) {
-  ASSERT(!value.IsEmpty());
+  DCHECK(!value.IsEmpty());
   v8::Local<v8::Value> array_value = object->GetInternalField(array_index);
   if (array_value->IsNull() || array_value->IsUndefined()) {
     array_value = v8::Array::New(isolate);
     object->SetInternalField(array_index, array_value);
   }
 
   v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(array_value);
   return V8CallBoolean(array->CreateDataProperty(isolate->GetCurrentContext(),
                                                  array->Length(), value));
 }
@@ skipping 66 matching lines @@
   if (!V8Call(v8::JSON::Parse(isolate, V8String(isolate, stringified_json)),
               parsed, try_catch)) {
     if (try_catch.HasCaught())
       exception_state.RethrowV8Exception(try_catch.Exception());
   }
 
   return parsed;
 }
 
 }  // namespace blink