[sql] Initialize StatisticsRecorder in SQLTestSuite.

sql/connection_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/metrics/statistics_recorder.h"
 #include "base/test/histogram_tester.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "sql/connection.h"
 #include "sql/connection_memory_dump_provider.h"
 #include "sql/correct_sql_test_base.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/test/error_callback_support.h"
 #include "sql/test/scoped_error_expecter.h"
 #include "sql/test/test_helpers.h"
@@ skipping 169 matching lines @@
 void ErrorCallbackResetHelper(sql::Connection* db,
                               size_t* counter,
                               const RefCounter& r,
                               int error, sql::Statement* stmt) {
   // The ref count should not go to zero when clearing the callback.
   EXPECT_GT(*counter, 0u);
   db->reset_error_callback();
   EXPECT_GT(*counter, 0u);
 }
 
+// Handle errors by blowing away the database.
+void RazeErrorCallback(sql::Connection* db,
+                       int expected_error,
+                       int error,
+                       sql::Statement* stmt) {
+  // Nothing here needs extended errors at this time.
+  EXPECT_EQ(expected_error, expected_error&0xff);
+  EXPECT_EQ(expected_error, error&0xff);
+  db->RazeAndClose();
+}
+
 #if defined(OS_POSIX)
 // Set a umask and restore the old mask on destruction.  Cribbed from
 // shared_memory_unittest.cc.  Used by POSIX-only UserPermission test.
 class ScopedUmaskSetter {
  public:
   explicit ScopedUmaskSetter(mode_t target_mask) {
     old_umask_ = umask(target_mask);
   }
   ~ScopedUmaskSetter() { umask(old_umask_); }
  private:
@@ skipping 18 matching lines @@
   return SQLITE_OK;
 }
 
 const char kCommitTime[] = "Sqlite.CommitTime.Test";
 const char kAutoCommitTime[] = "Sqlite.AutoCommitTime.Test";
 const char kUpdateTime[] = "Sqlite.UpdateTime.Test";
 const char kQueryTime[] = "Sqlite.QueryTime.Test";
 
 }  // namespace
 
-class SQLConnectionTest : public sql::SQLTestBase {
- public:
-  void SetUp() override {
-    // Any macro histograms which fire before the recorder is initialized cannot
-    // be tested.  So this needs to be ahead of Open().
-    base::StatisticsRecorder::Initialize();
-
-    SQLTestBase::SetUp();
-  }
-
-  // Handle errors by blowing away the database.
-  void RazeErrorCallback(int expected_error, int error, sql::Statement* stmt) {
-    // Nothing here needs extended errors at this time.
-    EXPECT_EQ(expected_error, expected_error&0xff);
-    EXPECT_EQ(expected_error, error&0xff);
-    db().RazeAndClose();
-  }
-};
+using SQLConnectionTest = sql::SQLTestBase;
 
 TEST_F(SQLConnectionTest, Execute) {
   // Valid statement should return true.
   ASSERT_TRUE(db().Execute("CREATE TABLE foo (a, b)"));
   EXPECT_EQ(SQLITE_OK, db().GetErrorCode());
 
   // Invalid statement should fail.
   ASSERT_EQ(SQLITE_ERROR,
             db().ExecuteAndReturnErrorCode("CREATE TAB foo (a, b"));
   EXPECT_EQ(SQLITE_ERROR, db().GetErrorCode());
@@ skipping 415 matching lines @@
   // fail with SQLITE_CORRUPT, as will this PRAGMA.
   {
     sql::test::ScopedErrorExpecter expecter;
     expecter.ExpectError(SQLITE_CORRUPT);
     ASSERT_TRUE(db().Open(db_path()));
     ASSERT_FALSE(db().Execute("PRAGMA auto_vacuum"));
     db().Close();
     ASSERT_TRUE(expecter.SawExpectedErrors());
   }
 
-  db().set_error_callback(base::Bind(&SQLConnectionTest::RazeErrorCallback,
-                                     base::Unretained(this),
+  db().set_error_callback(base::Bind(&RazeErrorCallback,
+                                     &db(),
                                      SQLITE_CORRUPT));
 
   // When the PRAGMA calls in Open() raise SQLITE_CORRUPT, the error
   // callback will call RazeAndClose().  Open() will then fail and be
   // retried.  The second Open() on the empty database will succeed
   // cleanly.
   ASSERT_TRUE(db().Open(db_path()));
   ASSERT_TRUE(db().Execute("PRAGMA auto_vacuum"));
   EXPECT_EQ(0, SqliteMasterCount(&db()));
 }
@@ skipping 224 matching lines @@
     ASSERT_FALSE(s.Step());
   }
 
   // The existing statement has become invalid.
   ASSERT_FALSE(valid_statement.is_valid());
   ASSERT_FALSE(valid_statement.Step());
 
   // Test that poisoning the database during a transaction works (with errors).
   // RazeErrorCallback() poisons the database, the extra COMMIT causes
   // CommitTransaction() to throw an error while commiting.
-  db().set_error_callback(base::Bind(&SQLConnectionTest::RazeErrorCallback,
-                                     base::Unretained(this),
+  db().set_error_callback(base::Bind(&RazeErrorCallback,
+                                     &db(),
                                      SQLITE_ERROR));
   db().Close();
   ASSERT_TRUE(db().Open(db_path()));
   EXPECT_TRUE(db().BeginTransaction());
   EXPECT_TRUE(db().Execute("INSERT INTO x VALUES ('x')"));
   EXPECT_TRUE(db().Execute("COMMIT"));
   EXPECT_FALSE(db().CommitTransaction());
 }
 
 // Test attaching and detaching databases from the connection.
@@ skipping 540 matching lines @@
   if (DLOG_IS_ON(FATAL)) {
     db().set_error_callback(base::Bind(&IgnoreErrorCallback));
     ASSERT_DEATH({
         db().GetUniqueStatement("SELECT x");
       }, "SQL compile error no such column: x");
   }
 #endif
 }
 
 }  // namespace sql