sql: Replace NULL with nullptr.

Change-Id: Ie3ad5785f82ccafdbcc630a5a26423ecc0b6c4bc
Reviewed-on: https://chromium-review.googlesource.com/1137846
Commit-Queue: Victor Costan <pwnall@chromium.org>
Reviewed-by: Chris Mumford <cmumford@chromium.org>
Cr-Commit-Position: refs/heads/master@{#575937}

sql/connection.cc

@@ -79,10 +79,10 @@ class ScopedWritableSchema {
  public:
   explicit ScopedWritableSchema(sqlite3* db)
       : db_(db) {
-    sqlite3_exec(db_, "PRAGMA writable_schema=1", NULL, NULL, NULL);
+    sqlite3_exec(db_, "PRAGMA writable_schema=1", nullptr, nullptr, nullptr);
   }
   ~ScopedWritableSchema() {
-    sqlite3_exec(db_, "PRAGMA writable_schema=0", NULL, NULL, NULL);
+    sqlite3_exec(db_, "PRAGMA writable_schema=0", nullptr, nullptr, nullptr);
   }
 
  private:
@@ -131,12 +131,12 @@ bool ValidAttachmentPoint(const char* attachment_point) {
 
 // Helper to get the sqlite3_file* associated with the "main" database.
 int GetSqlite3File(sqlite3* db, sqlite3_file** file) {
-  *file = NULL;
-  int rc = sqlite3_file_control(db, NULL, SQLITE_FCNTL_FILE_POINTER, file);
+  *file = nullptr;
+  int rc = sqlite3_file_control(db, nullptr, SQLITE_FCNTL_FILE_POINTER, file);
   if (rc != SQLITE_OK)
     return rc;
 
-  // TODO(shess): NULL in file->pMethods has been observed on android_dbg
+  // TODO(shess): null in file->pMethods has been observed on android_dbg
   // content_unittests, even though it should not be possible.
   // http://crbug.com/329982
   if (!*file || !(*file)->pMethods)
@@ -178,7 +178,7 @@ std::string AsUTF8ForSQL(const base::FilePath& path) {
 namespace sql {
 
 // static
-Connection::ErrorExpecterCallback* Connection::current_expecter_cb_ = NULL;
+Connection::ErrorExpecterCallback* Connection::current_expecter_cb_ = nullptr;
 
 // static
 bool Connection::IsExpectedSqliteError(int error) {
@@ -199,14 +199,14 @@ void Connection::ReportDiagnosticInfo(int extended_error, Statement* stmt) {
 
 // static
 void Connection::SetErrorExpecter(Connection::ErrorExpecterCallback* cb) {
-  CHECK(current_expecter_cb_ == NULL);
+  CHECK(!current_expecter_cb_);
   current_expecter_cb_ = cb;
 }
 
 // static
 void Connection::ResetErrorExpecter() {
   CHECK(current_expecter_cb_);
-  current_expecter_cb_ = NULL;
+  current_expecter_cb_ = nullptr;
 }
 
 bool StatementID::operator<(const StatementID& other) const {
@@ -242,9 +242,9 @@ void Connection::StatementRef::Close(bool forced) {
     // of the function. http://crbug.com/136655.
     AssertIOAllowed();
     sqlite3_finalize(stmt_);
-    stmt_ = NULL;
+    stmt_ = nullptr;
   }
-  connection_ = NULL;  // The connection may be getting deleted.
+  connection_ = nullptr;  // The connection may be getting deleted.
 
   // Forced close is expected to happen from a statement error
   // handler.  In that case maintain the sense of |was_valid_| which
@@ -253,7 +253,7 @@ void Connection::StatementRef::Close(bool forced) {
 }
 
 Connection::Connection()
-    : db_(NULL),
+    : db_(nullptr),
       page_size_(0),
       cache_size_(0),
       exclusive_locking_(false),
@@ -266,13 +266,12 @@ Connection::Connection()
       mmap_disabled_(false),
       mmap_enabled_(false),
       total_changes_at_last_release_(0),
-      stats_histogram_(NULL),
-      commit_time_histogram_(NULL),
-      autocommit_time_histogram_(NULL),
-      update_time_histogram_(NULL),
-      query_time_histogram_(NULL),
-      clock_(new TimeSource()) {
-}
+      stats_histogram_(nullptr),
+      commit_time_histogram_(nullptr),
+      autocommit_time_histogram_(nullptr),
+      update_time_histogram_(nullptr),
+      query_time_histogram_(nullptr),
+      clock_(new TimeSource()) {}
 
 Connection::~Connection() {
   Close();
@@ -410,7 +409,7 @@ void Connection::CloseInternal(bool forced) {
       DLOG(DCHECK) << "sqlite3_close failed: " << GetErrorMessage();
     }
   }
-  db_ = NULL;
+  db_ = nullptr;
 }
 
 void Connection::Close() {
@@ -440,7 +439,7 @@ void Connection::Preload() {
   if (preload_size < 1)
     return;
 
-  sqlite3_file* file = NULL;
+  sqlite3_file* file = nullptr;
   sqlite3_int64 file_size = 0;
   int rc = GetSqlite3FileAndSize(db_, &file, &file_size);
   if (rc != SQLITE_OK)
@@ -881,7 +880,7 @@ size_t Connection::GetAppropriateMmapSize() {
     // Read more of the database looking for errors.  The VFS interface is used
     // to assure that the reads are valid for SQLite.  |g_reads_allowed| is used
     // to limit checking to 20MB per run of Chromium.
-    sqlite3_file* file = NULL;
+    sqlite3_file* file = nullptr;
     sqlite3_int64 db_size = 0;
     if (SQLITE_OK != GetSqlite3FileAndSize(db_, &file, &db_size)) {
       RecordOneEvent(EVENT_MMAP_VFS_FAILURE);
@@ -1081,7 +1080,7 @@ bool Connection::Raze() {
   // TODO(shess): Maybe it would be worthwhile to just truncate from
   // the get-go?
   if (rc == SQLITE_NOTADB || rc == SQLITE_IOERR_SHORT_READ) {
-    sqlite3_file* file = NULL;
+    sqlite3_file* file = nullptr;
     rc = GetSqlite3File(db_, &file);
     if (rc != SQLITE_OK) {
       DLOG(DCHECK) << "Failure getting file handle.";
@@ -1167,7 +1166,7 @@ bool Connection::Delete(const base::FilePath& path) {
 
   EnsureSqliteInitialized();
 
-  sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);
+  sqlite3_vfs* vfs = sqlite3_vfs_find(nullptr);
   CHECK(vfs);
   CHECK(vfs->xDelete);
   CHECK(vfs->xAccess);
@@ -1315,7 +1314,7 @@ int Connection::ExecuteAndReturnErrorCode(const char* sql) {
   RecordOneEvent(EVENT_EXECUTE);
   int rc = SQLITE_OK;
   while ((rc == SQLITE_OK) && *sql) {
-    sqlite3_stmt *stmt = NULL;
+    sqlite3_stmt* stmt = nullptr;
     const char *leftover_sql;
 
     const base::TimeTicks before = Now();
@@ -1376,7 +1375,7 @@ bool Connection::Execute(const char* sql) {
 
   int error = ExecuteAndReturnErrorCode(sql);
   if (error != SQLITE_OK)
-    error = OnSqliteError(error, NULL, sql);
+    error = OnSqliteError(error, nullptr, sql);
 
   // This needs to be a FATAL log because the error case of arriving here is
   // that there's a malformed SQL statement. This can arise in development if
@@ -1437,14 +1436,14 @@ scoped_refptr<Connection::StatementRef> Connection::GetStatementImpl(
   if (!db_)
     return base::MakeRefCounted<StatementRef>(nullptr, nullptr, poisoned_);
 
-  sqlite3_stmt* stmt = NULL;
-  int rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL);
+  sqlite3_stmt* stmt = nullptr;
+  int rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
   if (rc != SQLITE_OK) {
     // This is evidence of a syntax error in the incoming SQL.
     DCHECK_NE(rc, SQLITE_ERROR) << "SQL compile error " << GetErrorMessage();
 
     // It could also be database corruption.
-    OnSqliteError(rc, NULL, sql);
+    OnSqliteError(rc, nullptr, sql);
     return base::MakeRefCounted<StatementRef>(nullptr, nullptr, false);
   }
   return base::MakeRefCounted<StatementRef>(tracking_db, stmt, true);
@@ -1452,7 +1451,7 @@ scoped_refptr<Connection::StatementRef> Connection::GetStatementImpl(
 
 scoped_refptr<Connection::StatementRef> Connection::GetUntrackedStatement(
     const char* sql) const {
-  return GetStatementImpl(NULL, sql);
+  return GetStatementImpl(nullptr, sql);
 }
 
 std::string Connection::GetSchema() const {
@@ -1485,8 +1484,8 @@ bool Connection::IsSQLValid(const char* sql) {
     return false;
   }
 
-  sqlite3_stmt* stmt = NULL;
-  if (sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL) != SQLITE_OK)
+  sqlite3_stmt* stmt = nullptr;
+  if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK)
     return false;
 
   sqlite3_finalize(stmt);
@@ -1570,7 +1569,7 @@ int Connection::GetLastErrno() const {
     return -1;
 
   int err = 0;
-  if (SQLITE_OK != sqlite3_file_control(db_, NULL, SQLITE_LAST_ERRNO, &err))
+  if (SQLITE_OK != sqlite3_file_control(db_, nullptr, SQLITE_LAST_ERRNO, &err))
     return -2;
 
   return err;
@@ -1643,7 +1642,7 @@ bool Connection::OpenInternal(const std::string& file_name,
     // purposes.
     base::UmaHistogramSparse("Sqlite.OpenFailure", err);
 
-    OnSqliteError(err, NULL, "-- sqlite3_open()");
+    OnSqliteError(err, nullptr, "-- sqlite3_open()");
     bool was_poisoned = poisoned_;
     Close();
 
@@ -1681,7 +1680,7 @@ bool Connection::OpenInternal(const std::string& file_name,
   // this to avoid the extra memory overhead.
   // This must be called immediatly after opening the database before any SQL
   // statements are run.
-  sqlite3_db_config(db_, SQLITE_DBCONFIG_LOOKASIDE, NULL, 0, 0);
+  sqlite3_db_config(db_, SQLITE_DBCONFIG_LOOKASIDE, nullptr, 0, 0);
 
   // Enable extended result codes to provide more color on I/O errors.
   // Not having extended result codes is not a fatal problem, as
@@ -1779,14 +1778,14 @@ bool Connection::OpenInternal(const std::string& file_name,
   // Database sizes seem to be bimodal, some clients have consistently small
   // databases (<20k) while other clients have a broad distribution of sizes
   // (hundreds of kilobytes to many megabytes).
-  sqlite3_file* file = NULL;
+  sqlite3_file* file = nullptr;
   sqlite3_int64 db_size = 0;
   int rc = GetSqlite3FileAndSize(db_, &file, &db_size);
   if (rc == SQLITE_OK && db_size > 16 * 1024) {
     int chunk_size = 4 * 1024;
     if (db_size > 128 * 1024)
       chunk_size = 32 * 1024;
-    sqlite3_file_control(db_, NULL, SQLITE_FCNTL_CHUNK_SIZE, &chunk_size);
+    sqlite3_file_control(db_, nullptr, SQLITE_FCNTL_CHUNK_SIZE, &chunk_size);
   }
 
   // Enable memory-mapped access.  The explicit-disable case is because SQLite

sql/connection.h

@@ -585,11 +585,11 @@ class SQL_EXPORT Connection {
 
     // |connection| is the sql::Connection instance associated with
     // the statement, and is used for tracking outstanding statements
-    // and for error handling.  Set to NULL for invalid or untracked
-    // refs.  |stmt| is the actual statement, and should only be NULL
+    // and for error handling.  Set to nullptr for invalid or untracked
+    // refs.  |stmt| is the actual statement, and should only be null
     // to create an invalid ref.  |was_valid| indicates whether the
     // statement should be considered valid for diagnistic purposes.
-    // |was_valid| can be true for NULL |stmt| if the connection has
+    // |was_valid| can be true for a null |stmt| if the connection has
     // been forcibly closed by an error handler.
     StatementRef(Connection* connection, sqlite3_stmt* stmt, bool was_valid);
 
@@ -601,18 +601,20 @@ class SQL_EXPORT Connection {
     // for diagnostic checks.
     bool was_valid() const { return was_valid_; }
 
-    // If we've not been linked to a connection, this will be NULL.
-    // TODO(shess): connection_ can be NULL in case of GetUntrackedStatement(),
-    // which prevents Statement::OnError() from forwarding errors.
+    // If we've not been linked to a connection, this will be null.
+    //
+    // TODO(shess): connection_ can be nullptr in case of
+    // GetUntrackedStatement(), which prevents Statement::OnError() from
+    // forwarding errors.
     Connection* connection() const { return connection_; }
 
     // Returns the sqlite statement if any. If the statement is not active,
-    // this will return NULL.
+    // this will return nullptr.
     sqlite3_stmt* stmt() const { return stmt_; }
 
-    // Destroys the compiled statement and marks it NULL. The statement will
-    // no longer be active.  |forced| is used to indicate if orderly-shutdown
-    // checks should apply (see Connection::RazeAndClose()).
+    // Destroys the compiled statement and sets it to nullptr. The statement
+    // will no longer be active. |forced| is used to indicate if
+    // orderly-shutdown checks should apply (see Connection::RazeAndClose()).
     void Close(bool forced);
 
     // Check whether the current thread is allowed to make IO calls, but only
@@ -643,10 +645,10 @@ class SQL_EXPORT Connection {
 
   // Called when a sqlite function returns an error, which is passed
   // as |err|.  The return value is the error code to be reflected
-  // back to client code.  |stmt| is non-NULL if the error relates to
-  // an sql::Statement instance.  |sql| is non-NULL if the error
+  // back to client code.  |stmt| is non-null if the error relates to
+  // an sql::Statement instance.  |sql| is non-nullptr if the error
   // relates to non-statement sql code (Execute, for instance).  Both
-  // can be NULL, but both should never be set.
+  // can be null, but both should never be set.
   // NOTE(shess): Originally, the return value was intended to allow
   // error handlers to transparently convert errors into success.
   // Unfortunately, transactions are not generally restartable, so
@@ -659,7 +661,7 @@ class SQL_EXPORT Connection {
 
   // Implementation helper for GetUniqueStatement() and GetUntrackedStatement().
   // |tracking_db| is the db the resulting ref should register with for
-  // outstanding statement tracking, which should be |this| to track or NULL to
+  // outstanding statement tracking, which should be |this| to track or null to
   // not track.
   scoped_refptr<StatementRef> GetStatementImpl(
       sql::Connection* tracking_db, const char* sql) const;
@@ -751,7 +753,7 @@ class SQL_EXPORT Connection {
   bool GetMmapAltStatus(int64_t* status);
   bool SetMmapAltStatus(int64_t status);
 
-  // The actual sqlite database. Will be NULL before Init has been called or if
+  // The actual sqlite database. Will be null before Init has been called or if
   // Init resulted in an error.
   sqlite3* db_;
 

sql/connection_unittest.cc

@@ -92,12 +92,12 @@ class ScopedScalarFunction {
       int args,
       base::RepeatingCallback<void(sqlite3_context*, int, sqlite3_value**)> cb)
       : db_(db.db_), function_name_(function_name), cb_(std::move(cb)) {
-    sqlite3_create_function_v2(db_, function_name, args, SQLITE_UTF8,
-                               this, &Run, NULL, NULL, NULL);
+    sqlite3_create_function_v2(db_, function_name, args, SQLITE_UTF8, this,
+                               &Run, nullptr, nullptr, nullptr);
   }
   ~ScopedScalarFunction() {
-    sqlite3_create_function_v2(db_, function_name_, 0, SQLITE_UTF8,
-                               NULL, NULL, NULL, NULL, NULL);
+    sqlite3_create_function_v2(db_, function_name_, 0, SQLITE_UTF8, nullptr,
+                               nullptr, nullptr, nullptr, nullptr);
   }
 
  private:
@@ -121,9 +121,7 @@ class ScopedCommitHook {
       : db_(db.db_), cb_(std::move(cb)) {
     sqlite3_commit_hook(db_, &Run, this);
   }
-  ~ScopedCommitHook() {
-    sqlite3_commit_hook(db_, NULL, NULL);
-  }
+  ~ScopedCommitHook() { sqlite3_commit_hook(db_, nullptr, nullptr); }
 
  private:
   static int Run(void* p) {
@@ -1445,7 +1443,7 @@ TEST_F(SQLConnectionTest, CollectDiagnosticInfo) {
 
   // Some other error doesn't include the statment.
   // TODO(shess): This is weak.
-  const std::string full_info = db().CollectErrorInfo(SQLITE_FULL, NULL);
+  const std::string full_info = db().CollectErrorInfo(SQLITE_FULL, nullptr);
   EXPECT_EQ(std::string::npos, full_info.find(kSimpleSql));
 
   // A table to see in the SQLITE_ERROR results.

sql/meta_table.cc

@@ -55,8 +55,7 @@ void RecordDeprecationEvent(DeprecationEventType deprecation_event) {
 
 namespace sql {
 
-MetaTable::MetaTable() : db_(NULL) {
-}
+MetaTable::MetaTable() : db_(nullptr) {}
 
 MetaTable::~MetaTable() = default;
 
@@ -147,7 +146,7 @@ bool MetaTable::Init(Connection* db, int version, int compatible_version) {
   DCHECK(!db_ && db);
   db_ = db;
 
-  // If values stored are null or missing entirely, 0 will be reported.
+  // If values stored are nullptr or missing entirely, 0 will be reported.
   // Require new clients to start with a greater initial version.
   DCHECK_GT(version, 0);
   DCHECK_GT(compatible_version, 0);
@@ -178,7 +177,7 @@ bool MetaTable::Init(Connection* db, int version, int compatible_version) {
 }
 
 void MetaTable::Reset() {
-  db_ = NULL;
+  db_ = nullptr;
 }
 
 void MetaTable::SetVersionNumber(int version) {

sql/recovery.cc

@@ -370,7 +370,7 @@ void Recovery::Shutdown(Recovery::Disposition raze) {
   } else if (raze == POISON) {
     db_->Poison();
   }
-  db_ = NULL;
+  db_ = nullptr;
 }
 
 bool Recovery::AutoRecoverTable(const char* table_name,

sql/recovery.h

@@ -70,7 +70,7 @@ class SQL_EXPORT Recovery {
   // and attach the existing database to it at "corrupt".  To prevent
   // deadlock, all transactions on |connection| are rolled back.
   //
-  // Returns NULL in case of failure, with no cleanup done on the
+  // Returns nullptr in case of failure, with no cleanup done on the
   // original connection (except for breaking the transactions).  The
   // caller should Raze() or otherwise cleanup as appropriate.
   //
@@ -123,7 +123,7 @@ class SQL_EXPORT Recovery {
   //
   // NOTE(shess): Due to a flaw in the recovery virtual table, at this
   // time this code injects the DEFAULT value of the target table in
-  // locations where the recovery table returns NULL.  This is not
+  // locations where the recovery table returns nullptr.  This is not
   // entirely correct, because it happens both when there is a short
   // row (correct) but also where there is an actual NULL value
   // (incorrect).

sql/recovery_unittest.cc

@@ -541,7 +541,7 @@ TEST_F(SQLRecoveryTest, AutoRecoverTableNullFilter) {
       "CREATE TABLE x (id INTEGER, t TEXT NOT NULL)";
 
   ASSERT_TRUE(db().Execute(kOrigSchema));
-  ASSERT_TRUE(db().Execute("INSERT INTO x VALUES (5, null)"));
+  ASSERT_TRUE(db().Execute("INSERT INTO x VALUES (5, NULL)"));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES (15, 'this is a test')"));
 
   // Create a lame-duck table which will not be propagated by recovery to
@@ -577,8 +577,8 @@ TEST_F(SQLRecoveryTest, AutoRecoverTableWithRowid) {
   static const char kCreateSql[] =
       "CREATE TABLE x (t TEXT, id INTEGER PRIMARY KEY NOT NULL)";
   ASSERT_TRUE(db().Execute(kCreateSql));
-  ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('This is a test', null)"));
-  ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('That was a test', null)"));
+  ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('This is a test', NULL)"));
+  ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('That was a test', NULL)"));
 
   // Save aside a copy of the original schema and data.
   const std::string orig_schema(GetSchema(&db()));

sql/sqlite_features_unittest.cc

@@ -38,7 +38,7 @@ using sql::test::ExecuteWithResults;
 void CaptureErrorCallback(int* error_pointer, std::string* sql_text,
                           int error, sql::Statement* stmt) {
   *error_pointer = error;
-  const char* text = stmt ? stmt->GetSQLStatement() : NULL;
+  const char* text = stmt ? stmt->GetSQLStatement() : nullptr;
   *sql_text = text ? text : "no statement available";
 }
 
@@ -339,8 +339,8 @@ TEST_F(SQLiteFeaturesTest, DISABLED_TimeMachine) {
   base::ScopedCFTypeRef<CFURLRef> journalURL(CFURLRefForPath(journal));
 
   // Not excluded to start.
-  EXPECT_FALSE(CSBackupIsItemExcluded(dbURL, NULL));
-  EXPECT_FALSE(CSBackupIsItemExcluded(journalURL, NULL));
+  EXPECT_FALSE(CSBackupIsItemExcluded(dbURL, nullptr));
+  EXPECT_FALSE(CSBackupIsItemExcluded(journalURL, nullptr));
 
   // Exclude the main database file.
   EXPECT_TRUE(base::mac::SetFileBackupExclusion(db_path()));
@@ -348,7 +348,7 @@ TEST_F(SQLiteFeaturesTest, DISABLED_TimeMachine) {
   Boolean excluded_by_path = FALSE;
   EXPECT_TRUE(CSBackupIsItemExcluded(dbURL, &excluded_by_path));
   EXPECT_FALSE(excluded_by_path);
-  EXPECT_FALSE(CSBackupIsItemExcluded(journalURL, NULL));
+  EXPECT_FALSE(CSBackupIsItemExcluded(journalURL, nullptr));
 
   EXPECT_TRUE(db().Open(db_path()));
   ASSERT_TRUE(db().Execute("INSERT INTO t VALUES (1)"));
@@ -478,9 +478,9 @@ TEST_F(SQLiteFeaturesTest, WALNoClose) {
   ASSERT_TRUE(Reopen());
   ASSERT_TRUE(db().Execute("PRAGMA journal_mode = WAL"));
   ASSERT_TRUE(db().Execute("ALTER TABLE foo ADD COLUMN c"));
-  ASSERT_EQ(
-      SQLITE_OK,
-      sqlite3_db_config(db().db_, SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, 1, NULL));
+  ASSERT_EQ(SQLITE_OK,
+            sqlite3_db_config(db().db_, SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, 1,
+                              nullptr));
   ASSERT_TRUE(GetPathExists(wal_path));
   db().Close();
   ASSERT_TRUE(GetPathExists(wal_path));

sql/statement.cc

@@ -15,7 +15,7 @@
 namespace sql {
 
 // This empty constructor initializes our reference with an empty one so that
-// we don't have to NULL-check the ref_ to see if the statement is valid: we
+// we don't have to null-check the ref_ to see if the statement is valid: we
 // only have to check the ref's validity bit.
 Statement::Statement()
     : ref_(base::MakeRefCounted<Connection::StatementRef>(nullptr,
@@ -288,7 +288,7 @@ int Statement::ColumnByteLength(int col) const {
 
 const void* Statement::ColumnBlob(int col) const {
   if (!CheckValid())
-    return NULL;
+    return nullptr;
 
   return sqlite3_column_blob(ref_->stmt(), col);
 }
@@ -358,7 +358,7 @@ int Statement::CheckError(int err) {
   // Please don't add DCHECKs here, OnSqliteError() already has them.
   succeeded_ = (err == SQLITE_OK || err == SQLITE_ROW || err == SQLITE_DONE);
   if (!succeeded_ && ref_.get() && ref_->connection())
-    return ref_->connection()->OnSqliteError(err, this, NULL);
+    return ref_->connection()->OnSqliteError(err, this, nullptr);
   return err;
 }
 

sql/statement.h

@@ -136,7 +136,7 @@ class SQL_EXPORT Statement {
 
   // When reading a blob, you can get a raw pointer to the underlying data,
   // along with the length, or you can just ask us to copy the blob into a
-  // vector. Danger! ColumnBlob may return NULL if there is no data!
+  // vector. Danger! ColumnBlob may return nullptr if there is no data!
   int ColumnByteLength(int col) const;
   const void* ColumnBlob(int col) const;
   bool ColumnBlobAsString(int col, std::string* blob) const;
@@ -188,7 +188,7 @@ class SQL_EXPORT Statement {
 
   // The actual sqlite statement. This may be unique to us, or it may be cached
   // by the connection, which is why it's refcounted. This pointer is
-  // guaranteed non-NULL.
+  // guaranteed non-null.
   scoped_refptr<Connection::StatementRef> ref_;
 
   // Set after Step() or Run() are called, reset by Reset().  Used to

sql/test/sql_test_base.cc

@@ -38,7 +38,7 @@ void SQLTestBase::WriteJunkToDatabase(WriteJunkType type) {
   base::ScopedFILE file(base::OpenFile(
       db_path(),
       type == TYPE_OVERWRITE_AND_TRUNCATE ? "wb" : "rb+"));
-  ASSERT_TRUE(file.get() != NULL);
+  ASSERT_TRUE(file.get());
   ASSERT_EQ(0, fseek(file.get(), 0, SEEK_SET));
 
   const char* kJunk = "Now is the winter of our discontent.";
@@ -47,7 +47,7 @@ void SQLTestBase::WriteJunkToDatabase(WriteJunkType type) {
 
 void SQLTestBase::TruncateDatabase() {
   base::ScopedFILE file(base::OpenFile(db_path(), "rb+"));
-  ASSERT_TRUE(file.get() != NULL);
+  ASSERT_TRUE(file);
   ASSERT_EQ(0, fseek(file.get(), 0, SEEK_SET));
   ASSERT_TRUE(base::TruncateFile(file.get()));
 }

sql/vfs_wrapper.cc

@@ -390,7 +390,7 @@ sqlite3_vfs* VFSWrapper() {
   // Return existing version if already registered.
   {
     sqlite3_vfs* vfs = sqlite3_vfs_find(kVFSName);
-    if (vfs != nullptr)
+    if (vfs)
       return vfs;
   }