[sql] sql::ScopedErrorIgnorer rename to sql::test::ScopedErrorExpecter

sql/connection.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sql/connection.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ skipping 210 matching lines @@
 #elif defined(OS_POSIX)
   return path.value();
 #endif
 }
 
 }  // namespace
 
 namespace sql {
 
 // static
-Connection::ErrorIgnorerCallback* Connection::current_ignorer_cb_ = NULL;
+Connection::ErrorExpecterCallback* Connection::current_expecter_cb_ = NULL;
 
 // static
-bool Connection::ShouldIgnoreSqliteError(int error) {
-  if (!current_ignorer_cb_)
+bool Connection::IsExpectedSqliteError(int error) {
+  if (!current_expecter_cb_)
     return false;
-  return current_ignorer_cb_->Run(error);
+  return current_expecter_cb_->Run(error);
 }
 
 // static
-bool Connection::ShouldIgnoreSqliteCompileError(int error) {
+bool Connection::IsExpectedSqliteCompileError(int error) {
   // Put this first in case tests need to see that the check happened.
-  if (ShouldIgnoreSqliteError(error))
+  if (IsExpectedSqliteError(error))
     return true;
 
   // Trim extended error codes.
   int basic_error = error & 0xff;
 
   // These errors relate more to the runtime context of the system than to
   // errors with a SQL statement or with the schema, so they aren't generally
   // interesting to flag.  This list is not comprehensive.
   return basic_error == SQLITE_BUSY ||
       basic_error == SQLITE_NOTADB ||
@@ skipping 22 matching lines @@
   if (!debug_info.empty() && RegisterIntentToUpload()) {
     char debug_buf[2000];
     base::strlcpy(debug_buf, debug_info.c_str(), arraysize(debug_buf));
     base::debug::Alias(&debug_buf);
 
     base::debug::DumpWithoutCrashing();
   }
 }
 
 // static
-void Connection::SetErrorIgnorer(Connection::ErrorIgnorerCallback* cb) {
-  CHECK(current_ignorer_cb_ == NULL);
-  current_ignorer_cb_ = cb;
+void Connection::SetErrorExpecter(Connection::ErrorExpecterCallback* cb) {
+  CHECK(current_expecter_cb_ == NULL);
+  current_expecter_cb_ = cb;
 }
 
 // static
-void Connection::ResetErrorIgnorer() {
-  CHECK(current_ignorer_cb_);
-  current_ignorer_cb_ = NULL;
+void Connection::ResetErrorExpecter() {
+  CHECK(current_expecter_cb_);
+  current_expecter_cb_ = NULL;
 }
 
 bool StatementID::operator<(const StatementID& other) const {
   if (number_ != other.number_)
     return number_ < other.number_;
   return strcmp(str_, other.str_) < 0;
 }
 
 Connection::StatementRef::StatementRef(Connection* connection,
                                        sqlite3_stmt* stmt,
@@ skipping 1158 matching lines @@
   AssertIOAllowed();
 
   // Return inactive statement.
   if (!db_)
     return new StatementRef(NULL, NULL, poisoned_);
 
   sqlite3_stmt* stmt = NULL;
   int rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL);
   if (rc != SQLITE_OK) {
     // This is evidence of a syntax error in the incoming SQL.
-    if (!ShouldIgnoreSqliteCompileError(rc))
+    if (!IsExpectedSqliteCompileError(rc))
       DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
 
     // It could also be database corruption.
     OnSqliteError(rc, NULL, sql);
     return new StatementRef(NULL, NULL, false);
   }
   return new StatementRef(this, stmt, true);
 }
 
 // TODO(shess): Unify this with GetUniqueStatement().  The only difference that
 // seems legitimate is not passing |this| to StatementRef.
 scoped_refptr<Connection::StatementRef> Connection::GetUntrackedStatement(
     const char* sql) const {
   // Return inactive statement.
   if (!db_)
     return new StatementRef(NULL, NULL, poisoned_);
 
   sqlite3_stmt* stmt = NULL;
   int rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL);
   if (rc != SQLITE_OK) {
     // This is evidence of a syntax error in the incoming SQL.
-    if (!ShouldIgnoreSqliteCompileError(rc))
+    if (!IsExpectedSqliteCompileError(rc))
       DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
     return new StatementRef(NULL, NULL, false);
   }
   return new StatementRef(NULL, stmt, true);
 }
 
 std::string Connection::GetSchema() const {
   // The ORDER BY should not be necessary, but relying on organic
   // order for something like this is questionable.
   const char* kSql =
@@ skipping 38 matching lines @@
 bool Connection::DoesIndexExist(const char* index_name) const {
   return DoesTableOrIndexExist(index_name, "index");
 }
 
 bool Connection::DoesTableOrIndexExist(
     const char* name, const char* type) const {
   const char* kSql =
       "SELECT name FROM sqlite_master WHERE type=? AND name=? COLLATE NOCASE";
   Statement statement(GetUntrackedStatement(kSql));
 
-  // This can happen if the database is corrupt and the error is being ignored
-  // for testing purposes.
+  // This can happen if the database is corrupt and the error is a test
+  // expectation.
   if (!statement.is_valid())
     return false;
 
   statement.BindString(0, type);
   statement.BindString(1, name);
 
   return statement.Step();  // Table exists if any row was returned.
 }
 
 bool Connection::DoesColumnExist(const char* table_name,
                                  const char* column_name) const {
   std::string sql("PRAGMA TABLE_INFO(");
   sql.append(table_name);
   sql.append(")");
 
   Statement statement(GetUntrackedStatement(sql.c_str()));
 
-  // This can happen if the database is corrupt and the error is being ignored
-  // for testing purposes.
+  // This can happen if the database is corrupt and the error is a test
+  // expectation.
   if (!statement.is_valid())
     return false;
 
   while (statement.Step()) {
     if (base::EqualsCaseInsensitiveASCII(statement.ColumnString(1),
                                          column_name))
       return true;
   }
   return false;
 }
@@ skipping 331 matching lines @@
 
   if (!error_callback_.is_null()) {
     // Fire from a copy of the callback in case of reentry into
     // re/set_error_callback().
     // TODO(shess): <http://crbug.com/254584>
     ErrorCallback(error_callback_).Run(err, stmt);
     return err;
   }
 
   // The default handling is to assert on debug and to ignore on release.
-  if (!ShouldIgnoreSqliteError(err))
+  if (!IsExpectedSqliteError(err))
     DLOG(FATAL) << GetErrorMessage();
   return err;
 }
 
 bool Connection::FullIntegrityCheck(std::vector<std::string>* messages) {
   return IntegrityCheckHelper("PRAGMA integrity_check", messages);
 }
 
 bool Connection::QuickIntegrityCheck() {
   std::vector<std::string> messages;
@@ skipping 36 matching lines @@
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql