Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/webdatabase

third_party/WebKit/Source/modules/webdatabase/sqlite/SQLiteStatement.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 68 matching lines @@
 namespace blink {
 
 SQLiteStatement::SQLiteStatement(SQLiteDatabase& db, const String& sql)
     : database_(db), query_(sql), statement_(0) {}
 
 SQLiteStatement::~SQLiteStatement() {
   Finalize();
 }
 
 int SQLiteStatement::Prepare() {
-  ASSERT(!is_prepared_);
+#if DCHECK_IS_ON()
+  DCHECK(!is_prepared_);
+#endif
 
   CString query = query_.StripWhiteSpace().Utf8();
 
   // Need to pass non-stack |const char*| and |sqlite3_stmt*| to avoid race
   // with Oilpan stack scanning.
   std::unique_ptr<const char*> tail = WTF::WrapUnique(new const char*);
   std::unique_ptr<sqlite3_stmt*> statement = WTF::WrapUnique(new sqlite3_stmt*);
   *tail = nullptr;
   *statement = nullptr;
   int error;
@@ skipping 49 matching lines @@
     return SQLITE_OK;
   SQL_DVLOG(1) << "SQL - finalize - " << query_;
   int result = sqlite3_finalize(statement_);
   statement_ = 0;
   return restrictError(result);
 }
 
 bool SQLiteStatement::ExecuteCommand() {
   if (!statement_ && Prepare() != SQLITE_OK)
     return false;
-  ASSERT(is_prepared_);
+#if DCHECK_IS_ON()
+  DCHECK(is_prepared_);
+#endif
   if (Step() != SQLITE_DONE) {
     Finalize();
     return false;
   }
   Finalize();
   return true;
 }
 
 int SQLiteStatement::BindText(int index, const String& text) {
-  ASSERT(is_prepared_);
-  ASSERT(index > 0);
-  ASSERT(static_cast<unsigned>(index) <= BindParameterCount());
+#if DCHECK_IS_ON()
+  DCHECK(is_prepared_);
+#endif
+  DCHECK_GT(index, 0);
+  DCHECK_LE(static_cast<unsigned>(index), BindParameterCount());
 
   String text16(text);
   text16.Ensure16Bit();
   return restrictError(
       sqlite3_bind_text16(statement_, index, text16.Characters16(),
                           sizeof(UChar) * text16.length(), SQLITE_TRANSIENT));
 }
 
 int SQLiteStatement::BindDouble(int index, double number) {
-  ASSERT(is_prepared_);
-  ASSERT(index > 0);
-  ASSERT(static_cast<unsigned>(index) <= BindParameterCount());
+#if DCHECK_IS_ON()
+  DCHECK(is_prepared_);
+#endif
+  DCHECK_GT(index, 0);
+  DCHECK_LE(static_cast<unsigned>(index), BindParameterCount());
 
   return restrictError(sqlite3_bind_double(statement_, index, number));
 }
 
 int SQLiteStatement::BindNull(int index) {
-  ASSERT(is_prepared_);
-  ASSERT(index > 0);
-  ASSERT(static_cast<unsigned>(index) <= BindParameterCount());
+#if DCHECK_IS_ON()
+  DCHECK(is_prepared_);
+#endif
+  DCHECK_GT(index, 0);
+  DCHECK_LE(static_cast<unsigned>(index), BindParameterCount());
 
   return restrictError(sqlite3_bind_null(statement_, index));
 }
 
 int SQLiteStatement::BindValue(int index, const SQLValue& value) {
   switch (value.GetType()) {
     case SQLValue::kStringValue:
       return BindText(index, value.GetString());
     case SQLValue::kNumberValue:
       return BindDouble(index, value.Number());
     case SQLValue::kNullValue:
       return BindNull(index);
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SQLITE_ERROR;
 }
 
 unsigned SQLiteStatement::BindParameterCount() const {
-  ASSERT(is_prepared_);
+#if DCHECK_IS_ON()
+  DCHECK(is_prepared_);
+#endif
   if (!statement_)
     return 0;
   return sqlite3_bind_parameter_count(statement_);
 }
 
 int SQLiteStatement::ColumnCount() {
-  ASSERT(is_prepared_);
+#if DCHECK_IS_ON()
+  DCHECK(is_prepared_);
+#endif
   if (!statement_)
     return 0;
   return sqlite3_data_count(statement_);
 }
 
 String SQLiteStatement::GetColumnName(int col) {
-  ASSERT(col >= 0);
+  DCHECK_GE(col, 0);
   if (!statement_)
     if (PrepareAndStep() != SQLITE_ROW)
       return String();
   if (ColumnCount() <= col)
     return String();
   return String(
       reinterpret_cast<const UChar*>(sqlite3_column_name16(statement_, col)));
 }
 
 SQLValue SQLiteStatement::GetColumnValue(int col) {
-  ASSERT(col >= 0);
+  DCHECK_GE(col, 0);
   if (!statement_)
     if (PrepareAndStep() != SQLITE_ROW)
       return SQLValue();
   if (ColumnCount() <= col)
     return SQLValue();
 
   // SQLite is typed per value. optional column types are
   // "(mostly) ignored"
   sqlite3_value* value = sqlite3_column_value(statement_, col);
   switch (sqlite3_value_type(value)) {
     case SQLITE_INTEGER:  // SQLValue and JS don't represent integers, so use
                           // FLOAT -case
     case SQLITE_FLOAT:
       return SQLValue(sqlite3_value_double(value));
     case SQLITE_BLOB:  // SQLValue and JS don't represent blobs, so use TEXT
                        // -case
     case SQLITE_TEXT: {
       const UChar* string =
           reinterpret_cast<const UChar*>(sqlite3_value_text16(value));
       unsigned length = sqlite3_value_bytes16(value) / sizeof(UChar);
       return SQLValue(StringImpl::Create8BitIfPossible(string, length));
     }
     case SQLITE_NULL:
       return SQLValue();
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SQLValue();
 }
 
 String SQLiteStatement::GetColumnText(int col) {
-  ASSERT(col >= 0);
+  DCHECK_GE(col, 0);
   if (!statement_)
     if (PrepareAndStep() != SQLITE_ROW)
       return String();
   if (ColumnCount() <= col)
     return String();
   const UChar* string =
       reinterpret_cast<const UChar*>(sqlite3_column_text16(statement_, col));
   return StringImpl::Create8BitIfPossible(
       string, sqlite3_column_bytes16(statement_, col) / sizeof(UChar));
 }
 
 int SQLiteStatement::GetColumnInt(int col) {
-  ASSERT(col >= 0);
+  DCHECK_GE(col, 0);
   if (!statement_)
     if (PrepareAndStep() != SQLITE_ROW)
       return 0;
   if (ColumnCount() <= col)
     return 0;
   return sqlite3_column_int(statement_, col);
 }
 
 int64_t SQLiteStatement::GetColumnInt64(int col) {
-  ASSERT(col >= 0);
+  DCHECK_GE(col, 0);
   if (!statement_)
     if (PrepareAndStep() != SQLITE_ROW)
       return 0;
   if (ColumnCount() <= col)
     return 0;
   return sqlite3_column_int64(statement_, col);
 }
 
 }  // namespace blink