Convert //sql to use std::unique_ptr

sql/recovery_unittest.cc

 // Copyright 2013 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/recovery.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "sql/connection.h"
@@ skipping 55 matching lines @@
   const char kCreateSql[] = "CREATE TABLE x (t TEXT)";
   const char kInsertSql[] = "INSERT INTO x VALUES ('This is a test')";
   const char kAltInsertSql[] = "INSERT INTO x VALUES ('That was a test')";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_TRUE(db().Execute(kInsertSql));
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   // If the Recovery handle goes out of scope without being
   // Recovered(), the database is razed.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery.get());
   }
   EXPECT_FALSE(db().is_open());
   ASSERT_TRUE(Reopen());
   EXPECT_TRUE(db().is_open());
   ASSERT_EQ("", GetSchema(&db()));
 
   // Recreate the database.
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_TRUE(db().Execute(kInsertSql));
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   // Unrecoverable() also razes.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery.get());
     sql::Recovery::Unrecoverable(std::move(recovery));
 
     // TODO(shess): Test that calls to recover.db() start failing.
   }
   EXPECT_FALSE(db().is_open());
   ASSERT_TRUE(Reopen());
   EXPECT_TRUE(db().is_open());
   ASSERT_EQ("", GetSchema(&db()));
 
   // Attempting to recover a previously-recovered handle fails early.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery.get());
     recovery.reset();
 
     recovery = sql::Recovery::Begin(&db(), db_path());
     ASSERT_FALSE(recovery.get());
   }
   ASSERT_TRUE(Reopen());
 
   // Recreate the database.
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_TRUE(db().Execute(kInsertSql));
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   // Unrecovered table to distinguish from recovered database.
   ASSERT_TRUE(db().Execute("CREATE TABLE y (c INTEGER)"));
   ASSERT_NE("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   // Recovered() replaces the original with the "recovered" version.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery.get());
 
     // Create the new version of the table.
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     // Insert different data to distinguish from original database.
     ASSERT_TRUE(recovery->db()->Execute(kAltInsertSql));
 
     // Successfully recovered.
     ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
   EXPECT_FALSE(db().is_open());
   ASSERT_TRUE(Reopen());
   EXPECT_TRUE(db().is_open());
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   const char* kXSql = "SELECT * FROM x ORDER BY 1";
   ASSERT_EQ("That was a test",
             ExecuteWithResults(&db(), kXSql, "|", "\n"));
 
   // Reset the database contents.
   ASSERT_TRUE(db().Execute("DELETE FROM x"));
   ASSERT_TRUE(db().Execute(kInsertSql));
 
   // Rollback() discards recovery progress and leaves the database as it was.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery.get());
 
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
     ASSERT_TRUE(recovery->db()->Execute(kAltInsertSql));
 
     sql::Recovery::Rollback(std::move(recovery));
   }
   EXPECT_FALSE(db().is_open());
   ASSERT_TRUE(Reopen());
   EXPECT_TRUE(db().is_open());
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   ASSERT_EQ("This is a test",
             ExecuteWithResults(&db(), kXSql, "|", "\n"));
 }
 
 // Test operation of the virtual table used by sql::Recovery.
 TEST_F(SQLRecoveryTest, VirtualTable) {
   const char kCreateSql[] = "CREATE TABLE x (t TEXT)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('This is a test')"));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('That was a test')"));
 
   // Successfully recover the database.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
 
     // Tables to recover original DB, now at [corrupt].
     const char kRecoveryCreateSql[] =
         "CREATE VIRTUAL TABLE temp.recover_x using recover("
         "  corrupt.x,"
         "  t TEXT STRICT"
         ")";
     ASSERT_TRUE(recovery->db()->Execute(kRecoveryCreateSql));
 
     // Re-create the original schema.
@@ skipping 19 matching lines @@
 }
 
 void RecoveryCallback(sql::Connection* db, const base::FilePath& db_path,
                       const char* create_table, const char* create_index,
                       int* record_error, int error, sql::Statement* stmt) {
   *record_error = error;
 
   // Clear the error callback to prevent reentrancy.
   db->reset_error_callback();
 
-  scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(db, db_path);
+  std::unique_ptr<sql::Recovery> recovery = sql::Recovery::Begin(db, db_path);
   ASSERT_TRUE(recovery.get());
 
   ASSERT_TRUE(recovery->db()->Execute(create_table));
   ASSERT_TRUE(recovery->db()->Execute(create_index));
 
   size_t rows = 0;
   ASSERT_TRUE(recovery->AutoRecoverTable("x", &rows));
 
   ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
 }
@@ skipping 144 matching lines @@
   const int kCompatibleVersion = 2;
 
   {
     sql::MetaTable meta;
     EXPECT_TRUE(meta.Init(&db(), kVersion, kCompatibleVersion));
     EXPECT_EQ(kVersion, meta.GetVersionNumber());
   }
 
   // Test expected case where everything works.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     EXPECT_TRUE(recovery->SetupMeta());
     int version = 0;
     EXPECT_TRUE(recovery->GetMetaVersionNumber(&version));
     EXPECT_EQ(kVersion, version);
 
     sql::Recovery::Rollback(std::move(recovery));
   }
   ASSERT_TRUE(Reopen());  // Handle was poisoned.
 
   // Test version row missing.
   EXPECT_TRUE(db().Execute("DELETE FROM meta WHERE key = 'version'"));
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     EXPECT_TRUE(recovery->SetupMeta());
     int version = 0;
     EXPECT_FALSE(recovery->GetMetaVersionNumber(&version));
     EXPECT_EQ(0, version);
 
     sql::Recovery::Rollback(std::move(recovery));
   }
   ASSERT_TRUE(Reopen());  // Handle was poisoned.
 
   // Test meta table missing.
   EXPECT_TRUE(db().Execute("DROP TABLE meta"));
   {
     sql::ScopedErrorIgnorer ignore_errors;
     ignore_errors.IgnoreError(SQLITE_CORRUPT);  // From virtual table.
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     EXPECT_FALSE(recovery->SetupMeta());
     ASSERT_TRUE(ignore_errors.CheckIgnoredErrors());
   }
 }
 
 // Baseline AutoRecoverTable() test.
 TEST_F(SQLRecoveryTest, AutoRecoverTable) {
   // BIGINT and VARCHAR to test type affinity.
   const char kCreateSql[] = "CREATE TABLE x (id BIGINT, t TEXT, v VARCHAR)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES (11, 'This is', 'a test')"));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES (5, 'That was', 'a test')"));
 
   // Save aside a copy of the original schema and data.
   const std::string orig_schema(GetSchema(&db()));
   const char kXSql[] = "SELECT * FROM x ORDER BY 1";
   const std::string orig_data(ExecuteWithResults(&db(), kXSql, "|", "\n"));
 
   // Create a lame-duck table which will not be propagated by recovery to
   // detect that the recovery code actually ran.
   ASSERT_TRUE(db().Execute("CREATE TABLE y (c TEXT)"));
   ASSERT_NE(orig_schema, GetSchema(&db()));
 
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     // Save a copy of the temp db's schema before recovering the table.
     const char kTempSchemaSql[] = "SELECT name, sql FROM sqlite_temp_master";
     const std::string temp_schema(
         ExecuteWithResults(recovery->db(), kTempSchemaSql, "|", "\n"));
 
     size_t rows = 0;
     EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(2u, rows);
 
     // Test that any additional temp tables were cleaned up.
     EXPECT_EQ(temp_schema,
               ExecuteWithResults(recovery->db(), kTempSchemaSql, "|", "\n"));
 
     ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 
   // Since the database was not corrupt, the entire schema and all
   // data should be recovered.
   ASSERT_TRUE(Reopen());
   ASSERT_EQ(orig_schema, GetSchema(&db()));
   ASSERT_EQ(orig_data, ExecuteWithResults(&db(), kXSql, "|", "\n"));
 
   // Recovery fails if the target table doesn't exist.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     // TODO(shess): Should this failure implicitly lead to Raze()?
     size_t rows = 0;
     EXPECT_FALSE(recovery->AutoRecoverTable("y", &rows));
 
     sql::Recovery::Unrecoverable(std::move(recovery));
   }
 }
 
@@ skipping 36 matching lines @@
   std::string final_data(orig_data);
   size_t pos;
   while ((pos = final_schema.find("'a''a'")) != std::string::npos) {
     final_schema.replace(pos, 6, "'c''c'");
   }
   while ((pos = final_data.find("5|a'a")) != std::string::npos) {
     final_data.replace(pos, 5, "5|c'c");
   }
 
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     // Different default to detect which table provides the default.
     ASSERT_TRUE(recovery->db()->Execute(final_schema.c_str()));
 
     size_t rows = 0;
     EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(4u, rows);
 
     ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 
@@ skipping 16 matching lines @@
   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
   // detect that the recovery code actually ran.
   ASSERT_EQ(kOrigSchema, GetSchema(&db()));
   ASSERT_TRUE(db().Execute("CREATE TABLE y (c TEXT)"));
   ASSERT_NE(kOrigSchema, GetSchema(&db()));
 
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery->db()->Execute(kFinalSchema));
 
     size_t rows = 0;
     EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(1u, rows);
 
     ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 
   // The schema should be the same, but only one row of data should
@@ skipping 18 matching lines @@
   const std::string orig_schema(GetSchema(&db()));
   const char kXSql[] = "SELECT * FROM x ORDER BY 1";
   const std::string orig_data(ExecuteWithResults(&db(), kXSql, "|", "\n"));
 
   // Create a lame-duck table which will not be propagated by recovery to
   // detect that the recovery code actually ran.
   ASSERT_TRUE(db().Execute("CREATE TABLE y (c TEXT)"));
   ASSERT_NE(orig_schema, GetSchema(&db()));
 
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     size_t rows = 0;
     EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(2u, rows);
 
     ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 
   // Since the database was not corrupt, the entire schema and all
@@ skipping 24 matching lines @@
   const std::string orig_schema(GetSchema(&db()));
   const char kXSql[] = "SELECT * FROM x ORDER BY 1";
   const std::string orig_data(ExecuteWithResults(&db(), kXSql, "|", "\n"));
 
   // Create a lame-duck table which will not be propagated by recovery to
   // detect that the recovery code actually ran.
   ASSERT_TRUE(db().Execute("CREATE TABLE y (c TEXT)"));
   ASSERT_NE(orig_schema, GetSchema(&db()));
 
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     size_t rows = 0;
     EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(3u, rows);
 
     ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 
   // Since the database was not corrupt, the entire schema and all
@@ skipping 25 matching lines @@
     expected_data = ExecuteWithResults(&db(), kXSql, "|", "\n");
 
     db().RollbackTransaction();
   }
 
   // Following tests are pointless if the rollback didn't work.
   ASSERT_EQ(orig_schema, GetSchema(&db()));
 
   // Recover the previous version of the table into the altered version.
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
     ASSERT_TRUE(recovery->db()->Execute(kAlterSql));
     size_t rows = 0;
     EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(2u, rows);
     ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 
   // Since the database was not corrupt, the entire schema and all
   // data should be recovered.
   ASSERT_TRUE(Reopen());
   ASSERT_EQ(expected_schema, GetSchema(&db()));
   ASSERT_EQ(expected_data, ExecuteWithResults(&db(), kXSql, "|", "\n"));
 }
 
 // Recover a golden file where an interior page has been manually modified so
 // that the number of cells is greater than will fit on a single page.  This
 // case happened in <http://crbug.com/387868>.
 TEST_F(SQLRecoveryTest, Bug387868) {
   base::FilePath golden_path;
   ASSERT_TRUE(PathService::Get(sql::test::DIR_TEST_DATA, &golden_path));
   golden_path = golden_path.AppendASCII("recovery_387868");
   db().Close();
   ASSERT_TRUE(base::CopyFile(golden_path, db_path()));
   ASSERT_TRUE(Reopen());
 
   {
-    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+    std::unique_ptr<sql::Recovery> recovery =
+        sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery.get());
 
     // Create the new version of the table.
     const char kCreateSql[] =
         "CREATE TABLE x (id INTEGER PRIMARY KEY, t0 TEXT)";
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     size_t rows = 0;
     EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(43u, rows);
 
     // Successfully recovered.
     EXPECT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 }
 
 // Memory-mapped I/O interacts poorly with I/O errors.  Make sure the recovery
 // database doesn't accidentally enable it.
 TEST_F(SQLRecoveryTest, NoMmap) {
-  scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+  std::unique_ptr<sql::Recovery> recovery =
+      sql::Recovery::Begin(&db(), db_path());
   ASSERT_TRUE(recovery.get());
 
   // In the current implementation, the PRAGMA successfully runs with no result
   // rows.  Running with a single result of |0| is also acceptable.
   sql::Statement s(recovery->db()->GetUniqueStatement("PRAGMA mmap_size"));
   EXPECT_TRUE(!s.Step() || !s.ColumnInt64(0));
 }
 
 }  // namespace