[sql] Remove misleading AutoRecoverTable() parameter.

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 <string>
 #include <utility>
 
@@ skipping 411 matching lines @@
   {
     scoped_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", 0, &rows));
+    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());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     // TODO(shess): Should this failure implicitly lead to Raze()?
     size_t rows = 0;
-    EXPECT_FALSE(recovery->AutoRecoverTable("y", 0, &rows));
+    EXPECT_FALSE(recovery->AutoRecoverTable("y", &rows));
 
     sql::Recovery::Unrecoverable(std::move(recovery));
   }
 }
 
 // Test that default values correctly replace nulls.  The recovery
 // virtual table reads directly from the database, so DEFAULT is not
 // interpretted at that level.
 TEST_F(SQLRecoveryTest, AutoRecoverTableWithDefault) {
   ASSERT_TRUE(db().Execute("CREATE TABLE x (id INTEGER)"));
@@ skipping 36 matching lines @@
   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());
     // 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", 0, &rows));
+    EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(4u, 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(final_schema, GetSchema(&db()));
   ASSERT_EQ(final_data, ExecuteWithResults(&db(), kXSql, "|", "\n"));
@@ skipping 15 matching lines @@
   // 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());
     ASSERT_TRUE(recovery->db()->Execute(kFinalSchema));
 
     size_t rows = 0;
-    EXPECT_TRUE(recovery->AutoRecoverTable("x", 0, &rows));
+    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
   // have been recovered.
   ASSERT_TRUE(Reopen());
   ASSERT_EQ(kFinalSchema, GetSchema(&db()));
   const char kXSql[] = "SELECT * FROM x ORDER BY 1";
@@ skipping 18 matching lines @@
   // 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());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     size_t rows = 0;
-    EXPECT_TRUE(recovery->AutoRecoverTable("x", 0, &rows));
+    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(orig_schema, GetSchema(&db()));
   ASSERT_EQ(orig_data, ExecuteWithResults(&db(), kXSql, "|", "\n"));
@@ skipping 24 matching lines @@
   // 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());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     size_t rows = 0;
-    EXPECT_TRUE(recovery->AutoRecoverTable("x", 0, &rows));
+    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
   // data should be recovered.
   ASSERT_TRUE(Reopen());
   ASSERT_EQ(orig_schema, GetSchema(&db()));
   ASSERT_EQ(orig_data, ExecuteWithResults(&db(), kXSql, "|", "\n"));
 }
 
-// Test |extend_columns| support.
-TEST_F(SQLRecoveryTest, AutoRecoverTableExtendColumns) {
+// Test recovering from a table with fewer columns than the target.
+TEST_F(SQLRecoveryTest, AutoRecoverTableMissingColumns) {
   const char kCreateSql[] = "CREATE TABLE x (id INTEGER PRIMARY KEY, t0 TEXT)";
+  const char kAlterSql[] = "ALTER TABLE x ADD COLUMN t1 TEXT DEFAULT 't'";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES (1, 'This is')"));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES (2, 'That was')"));
 
-  // Save aside a copy of the original schema and data.
+  // Generate the expected info by faking a table to match what recovery will
+  // create.
   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"));
+  std::string expected_schema;
+  std::string expected_data;
+  {
+    ASSERT_TRUE(db().BeginTransaction());
+    ASSERT_TRUE(db().Execute(kAlterSql));
 
-  // Modify the table to add a column, and add data to that column.
-  ASSERT_TRUE(db().Execute("ALTER TABLE x ADD COLUMN t1 TEXT"));
-  ASSERT_TRUE(db().Execute("UPDATE x SET t1 = 'a test'"));
-  ASSERT_NE(orig_schema, GetSchema(&db()));
-  ASSERT_NE(orig_data, ExecuteWithResults(&db(), kXSql, "|", "\n"));
+    expected_schema = GetSchema(&db());
+    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());
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
+    ASSERT_TRUE(recovery->db()->Execute(kAlterSql));
     size_t rows = 0;
-    EXPECT_TRUE(recovery->AutoRecoverTable("x", 1, &rows));
+    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(orig_schema, GetSchema(&db()));
-  ASSERT_EQ(orig_data, ExecuteWithResults(&db(), kXSql, "|", "\n"));
+  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());
     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", 0, &rows));
+    EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(43u, rows);
 
     // Successfully recovered.
     EXPECT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 }
 #endif  // !defined(USE_SYSTEM_SQLITE)
 
 // 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());
   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