Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/indexeddb

third_party/WebKit/Source/modules/indexeddb/IDBKeyPath.cpp

 /*
  * Copyright (C) 2010 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 82 matching lines @@
     if (!IsIdentifier(elements[i])) {
       error = kIDBKeyPathParseErrorIdentifier;
       return;
     }
   }
   error = kIDBKeyPathParseErrorNone;
 }
 
 IDBKeyPath::IDBKeyPath(const String& string)
     : type_(kStringType), string_(string) {
-  ASSERT(!string_.IsNull());
+  DCHECK(!string_.IsNull());
 }
 
 IDBKeyPath::IDBKeyPath(const Vector<String>& array)
     : type_(kArrayType), array_(array) {
 #if DCHECK_IS_ON()
   for (size_t i = 0; i < array_.size(); ++i)
-    ASSERT(!array_[i].IsNull());
+    DCHECK(!array_[i].IsNull());
 #endif
 }
 
 IDBKeyPath::IDBKeyPath(const StringOrStringSequence& key_path) {
   if (key_path.isNull()) {
     type_ = kNullType;
   } else if (key_path.isString()) {
     type_ = kStringType;
     string_ = key_path.getAsString();
-    ASSERT(!string_.IsNull());
+    DCHECK(!string_.IsNull());
   } else {
-    ASSERT(key_path.isStringSequence());
+    DCHECK(key_path.isStringSequence());
     type_ = kArrayType;
     array_ = key_path.getAsStringSequence();
 #if DCHECK_IS_ON()
     for (size_t i = 0; i < array_.size(); ++i)
-      ASSERT(!array_[i].IsNull());
+      DCHECK(!array_[i].IsNull());
 #endif
   }
 }
 
 IDBKeyPath::IDBKeyPath(const WebIDBKeyPath& key_path) {
   switch (key_path.KeyPathType()) {
     case kWebIDBKeyPathTypeNull:
       type_ = kNullType;
       return;
 
     case kWebIDBKeyPathTypeString:
       type_ = kStringType;
       string_ = key_path.GetString();
       return;
 
     case kWebIDBKeyPathTypeArray:
       type_ = kArrayType;
       for (size_t i = 0, size = key_path.Array().size(); i < size; ++i)
         array_.push_back(key_path.Array()[i]);
       return;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
 }
 
 IDBKeyPath::operator WebIDBKeyPath() const {
   switch (type_) {
     case kNullType:
       return WebIDBKeyPath();
     case kStringType:
       return WebIDBKeyPath(WebString(string_));
     case kArrayType:
       return WebIDBKeyPath(array_);
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return WebIDBKeyPath();
 }
 
 bool IDBKeyPath::IsValid() const {
   switch (type_) {
     case kNullType:
       return false;
 
     case kStringType:
       return IDBIsValidKeyPath(string_);
 
     case kArrayType:
       if (array_.IsEmpty())
         return false;
       for (size_t i = 0; i < array_.size(); ++i) {
         if (!IDBIsValidKeyPath(array_[i]))
           return false;
       }
       return true;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return false;
 }
 
 bool IDBKeyPath::operator==(const IDBKeyPath& other) const {
   if (type_ != other.type_)
     return false;
 
   switch (type_) {
     case kNullType:
       return true;
     case kStringType:
       return string_ == other.string_;
     case kArrayType:
       return array_ == other.array_;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return false;
 }
 
 }  // namespace blink