Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

third_party/WebKit/Source/bindings/modules/v8/V8BindingForModules.cpp

 /*
  * Copyright (C) 2011 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:
  *
  * 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 55 matching lines @@
                           v8::Local<v8::Object> creation_context,
                           v8::Isolate* isolate) {
   switch (value.GetType()) {
     case IDBKeyPath::kNullType:
       return v8::Null(isolate);
     case IDBKeyPath::kStringType:
       return V8String(isolate, value.GetString());
     case IDBKeyPath::kArrayType:
       return ToV8(value.Array(), creation_context, isolate);
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return v8::Undefined(isolate);
 }
 
 v8::Local<v8::Value> ToV8(const IDBKey* key,
                           v8::Local<v8::Object> creation_context,
                           v8::Isolate* isolate) {
   if (!key) {
     // The IndexedDB spec requires that absent keys appear as attribute
     // values as undefined, rather than the more typical (for DOM) null.
     // This appears on the |upper| and |lower| attributes of IDBKeyRange.
@@ skipping 27 matching lines @@
             ToV8(key->Array()[i].Get(), creation_context, isolate);
         if (value.IsEmpty())
           value = v8::Undefined(isolate);
         if (!V8CallBoolean(array->CreateDataProperty(context, i, value)))
           return V8Undefined();
       }
       return array;
     }
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return V8Undefined();
 }
 
 // IDBAny is a variant type used to hold the values produced by the |result|
 // attribute of IDBRequest and (as a convenience) the |source| attribute of
 // IDBRequest and IDBCursor.
 // TODO(jsbell): Replace the use of IDBAny for |source| attributes (which are
 // ScriptWrappable types) using unions per IDL.
 v8::Local<v8::Value> ToV8(const IDBAny* impl,
                           v8::Local<v8::Object> creation_context,
@@ skipping 22 matching lines @@
       return DeserializeIDBValue(isolate, creation_context, impl->Value());
     case IDBAny::kIDBValueArrayType:
       return DeserializeIDBValueArray(isolate, creation_context,
                                       impl->Values());
     case IDBAny::kIntegerType:
       return v8::Number::New(isolate, impl->Integer());
     case IDBAny::kKeyType:
       return ToV8(impl->Key(), creation_context, isolate);
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return v8::Undefined(isolate);
 }
 
 static const size_t kMaximumDepth = 2000;
 
 static IDBKey* CreateIDBKeyFromValue(v8::Isolate* isolate,
                                      v8::Local<v8::Value> value,
                                      Vector<v8::Local<v8::Array>>& stack,
                                      ExceptionState& exception_state) {
   if (value->IsNumber() && !std::isnan(value.As<v8::Number>()->Value()))
@@ skipping 87 matching lines @@
     return name == "name" || name == "lastModified" ||
            name == "lastModifiedDate";
   return false;
 }
 
 // Assumes a valid key path.
 static Vector<String> ParseKeyPath(const String& key_path) {
   Vector<String> elements;
   IDBKeyPathParseError error;
   IDBParseKeyPath(key_path, elements, error);
-  ASSERT(error == kIDBKeyPathParseErrorNone);
+  DCHECK_EQ(error, kIDBKeyPathParseErrorNone);
   return elements;
 }
 
 static IDBKey* CreateIDBKeyFromValueAndKeyPath(
     v8::Isolate* isolate,
     v8::Local<v8::Value> v8_value,
     const String& key_path,
     ExceptionState& exception_state) {
   Vector<String> key_path_elements = ParseKeyPath(key_path);
-  ASSERT(isolate->InContext());
+  DCHECK(isolate->InContext());
 
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::TryCatch block(isolate);
   for (size_t i = 0; i < key_path_elements.size(); ++i) {
     const String& element = key_path_elements[i];
 
     // Special cases from https://w3c.github.io/IndexedDB/#key-path-construct
     // These access special or non-own properties directly, to avoid side
     // effects.
@@ skipping 53 matching lines @@
     }
   }
   return CreateIDBKeyFromValue(isolate, v8_value, exception_state);
 }
 
 static IDBKey* CreateIDBKeyFromValueAndKeyPath(
     v8::Isolate* isolate,
     v8::Local<v8::Value> value,
     const IDBKeyPath& key_path,
     ExceptionState& exception_state) {
-  ASSERT(!key_path.IsNull());
+  DCHECK(!key_path.IsNull());
   v8::HandleScope handle_scope(isolate);
   if (key_path.GetType() == IDBKeyPath::kArrayType) {
     IDBKey::KeyArray result;
     const Vector<String>& array = key_path.Array();
     for (size_t i = 0; i < array.size(); ++i) {
       IDBKey* key = CreateIDBKeyFromValueAndKeyPath(isolate, value, array[i],
                                                     exception_state);
       if (!key)
         return nullptr;
       result.push_back(key);
     }
     return IDBKey::CreateArray(result);
   }
 
-  ASSERT(key_path.GetType() == IDBKeyPath::kStringType);
+  DCHECK_EQ(key_path.GetType(), IDBKeyPath::kStringType);
   return CreateIDBKeyFromValueAndKeyPath(isolate, value, key_path.GetString(),
                                          exception_state);
 }
 
 // Deserialize just the value data & blobInfo from the given IDBValue.
 //
 // Primary key injection is performed in deserializeIDBValue() below.
 static v8::Local<v8::Value> DeserializeIDBValueData(v8::Isolate* isolate,
                                                     const IDBValue* value) {
-  ASSERT(isolate->InContext());
+  DCHECK(isolate->InContext());
   if (!value || value->IsNull())
     return v8::Null(isolate);
 
   RefPtr<SerializedScriptValue> serialized_value =
       value->CreateSerializedValue();
   SerializedScriptValue::DeserializeOptions options;
   options.blob_info = value->BlobInfo();
   options.read_wasm_from_stream = true;
 
   // deserialize() returns null when serialization fails.  This is sub-optimal
   // because IndexedDB values can be null, so an application cannot distinguish
   // between a de-serialization failure and a legitimately stored null value.
   //
   // TODO(crbug.com/703704): Ideally, SerializedScriptValue should return an
   // empty handle on serialization errors, which should be handled by higher
   // layers. For example, IndexedDB could throw an exception, abort the
   // transaction, or close the database connection.
   return serialized_value->Deserialize(isolate, options);
 }
 
 // Deserialize the entire IDBValue.
 //
 // On top of deserializeIDBValueData(), this handles the special case of having
 // to inject a key into the de-serialized value. See injectV8KeyIntoV8Value()
 // for details.
 v8::Local<v8::Value> DeserializeIDBValue(v8::Isolate* isolate,
                                          v8::Local<v8::Object> creation_context,
                                          const IDBValue* value) {
-  ASSERT(isolate->InContext());
+  DCHECK(isolate->InContext());
   if (!value || value->IsNull())
     return v8::Null(isolate);
 
   v8::Local<v8::Value> v8_value = DeserializeIDBValueData(isolate, value);
   if (value->PrimaryKey()) {
     v8::Local<v8::Value> key =
         ToV8(value->PrimaryKey(), creation_context, isolate);
     if (key.IsEmpty())
       return v8::Local<v8::Value>();
 
     InjectV8KeyIntoV8Value(isolate, key, v8_value, value->KeyPath());
 
     // TODO(crbug.com/703704): Throw an error here or at a higher layer if
     // injectV8KeyIntoV8Value() returns false, which means that the serialized
     // value got corrupted while on disk.
   }
 
   return v8_value;
 }
 
 static v8::Local<v8::Value> DeserializeIDBValueArray(
     v8::Isolate* isolate,
     v8::Local<v8::Object> creation_context,
     const Vector<RefPtr<IDBValue>>* values) {
-  ASSERT(isolate->InContext());
+  DCHECK(isolate->InContext());
 
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Array> array = v8::Array::New(isolate, values->size());
   for (size_t i = 0; i < values->size(); ++i) {
     v8::Local<v8::Value> v8_value =
         DeserializeIDBValue(isolate, creation_context, values->at(i).Get());
     if (v8_value.IsEmpty())
       v8_value = v8::Undefined(isolate);
     if (!V8CallBoolean(array->CreateDataProperty(context, i, v8_value)))
       return V8Undefined();
@@ skipping 17 matching lines @@
 // because this type of code is a likely victim to security exploits.
 //
 // We handle this special case by serializing and writing values without the
 // corresponding keys. At read time, we obtain the keys and the values
 // separately, and we inject the keys into values.
 bool InjectV8KeyIntoV8Value(v8::Isolate* isolate,
                             v8::Local<v8::Value> key,
                             v8::Local<v8::Value> value,
                             const IDBKeyPath& key_path) {
   IDB_TRACE("injectIDBV8KeyIntoV8Value");
-  ASSERT(isolate->InContext());
+  DCHECK(isolate->InContext());
 
-  ASSERT(key_path.GetType() == IDBKeyPath::kStringType);
+  DCHECK_EQ(key_path.GetType(), IDBKeyPath::kStringType);
   Vector<String> key_path_elements = ParseKeyPath(key_path.GetString());
 
   // The conbination of a key generator and an empty key path is forbidden by
   // spec.
   if (!key_path_elements.size()) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return false;
   }
 
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   // For an object o = {} which should have keypath 'a.b.c' and key k, this
   // populates o to be {a:{b:{}}}. This is only applied to deserialized
   // values, so we can assume that there are no getters/setters on the
   // object itself (though there might be on the prototype chain).
@@ skipping 16 matching lines @@
   //
   // (2) Bugs that write a value which is incompatible with the primary key
   // injection required by the object store. The simplest example is writing
   // numbers or booleans to an object store with an auto-incrementing primary
   // keys.
   for (size_t i = 0; i < key_path_elements.size() - 1; ++i) {
     if (!value->IsObject())
       return false;
 
     const String& key_path_element = key_path_elements[i];
-    ASSERT(!IsImplicitProperty(isolate, value, key_path_element));
+    DCHECK(!IsImplicitProperty(isolate, value, key_path_element));
     v8::Local<v8::Object> object = value.As<v8::Object>();
     v8::Local<v8::String> property = V8String(isolate, key_path_element);
     bool has_own_property;
     if (!V8Call(object->HasOwnProperty(context, property), has_own_property))
       return false;
     if (has_own_property) {
       if (!object->Get(context, property).ToLocal(&value))
         return false;
     } else {
       value = v8::Object::New(isolate);
@@ skipping 22 matching lines @@
   return true;
 }
 
 // Verify that an value can have an generated key inserted at the location
 // specified by the key path (by injectV8KeyIntoV8Value) when the object is
 // later deserialized.
 bool CanInjectIDBKeyIntoScriptValue(v8::Isolate* isolate,
                                     const ScriptValue& script_value,
                                     const IDBKeyPath& key_path) {
   IDB_TRACE("canInjectIDBKeyIntoScriptValue");
-  ASSERT(key_path.GetType() == IDBKeyPath::kStringType);
+  DCHECK_EQ(key_path.GetType(), IDBKeyPath::kStringType);
   Vector<String> key_path_elements = ParseKeyPath(key_path.GetString());
 
   if (!key_path_elements.size())
     return false;
 
   v8::Local<v8::Value> current(script_value.V8Value());
   if (!current->IsObject())
     return false;
 
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ skipping 81 matching lines @@
                                        const IDBValue* value) {
   ScriptState::Scope scope(script_state);
   v8::Isolate* isolate = script_state->GetIsolate();
   ScriptValue key_value = ScriptValue::From(script_state, value->PrimaryKey());
   ScriptValue script_value(script_state,
                            DeserializeIDBValueData(isolate, value));
 
   DummyExceptionStateForTesting exception_state;
   IDBKey* expected_key = CreateIDBKeyFromValueAndKeyPath(
       isolate, script_value.V8Value(), value->KeyPath(), exception_state);
-  ASSERT(!exception_state.HadException());
+  DCHECK(!exception_state.HadException());
   if (expected_key && expected_key->IsEqual(value->PrimaryKey()))
     return;
 
   bool injected = InjectV8KeyIntoV8Value(
       isolate, key_value.V8Value(), script_value.V8Value(), value->KeyPath());
   DCHECK(injected);
 }
 #endif
 
 }  // namespace blink