Remove the protector service.

chrome/browser/webdata/web_database_migration_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 <string>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/guid.h"
 #include "base/message_loop.h"
@@ skipping 107 matching lines @@
   credit_card->SetRawInfo(CREDIT_CARD_EXP_MONTH, s.ColumnString16(2));
   credit_card->SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, s.ColumnString16(3));
   int encrypted_number_len = s.ColumnByteLength(4);
   if (encrypted_number_len) {
     encrypted_number->resize(encrypted_number_len);
     memcpy(&(*encrypted_number)[0], s.ColumnBlob(4), encrypted_number_len);
   }
   *date_modified = s.ColumnInt64(5);
 }
 
+void CheckHasBackupData(sql::MetaTable* meta_table) {
+  std::string value;
+  EXPECT_TRUE(meta_table->GetValue(
+      "Default Search Provider ID Backup", &value));
+  EXPECT_TRUE(meta_table->GetValue(
+      "Default Search Provider ID Backup Signature", &value));
+}
+
+void CheckNoBackupData(const sql::Connection& connection,
+                       sql::MetaTable* meta_table) {
+  std::string value;
+  EXPECT_FALSE(meta_table->GetValue(
+      "Default Search Provider ID Backup", &value));
+  EXPECT_FALSE(meta_table->GetValue(
+      "Default Search Provider ID Backup Signature", &value));
+  EXPECT_FALSE(connection.DoesTableExist("keywords_backup"));
+}
+
 }  // anonymous namespace
 
 // The WebDatabaseMigrationTest encapsulates testing of database migrations.
 // Specifically, these tests are intended to exercise any schema changes in
 // the WebDatabase and data migrations that occur in
 // |WebDatabase::MigrateOldVersionsAsNeeded()|.
 class WebDatabaseMigrationTest : public testing::Test {
  public:
   // In order to access the application locale -- which the tested functions do
   // internally -- this test must run on the UI thread.
@@ skipping 50 matching lines @@
   void LoadDatabase(const FilePath::StringType& file);
 
  private:
   MessageLoopForUI message_loop_for_ui_;
   content::TestBrowserThread ui_thread_;
   base::ScopedTempDir temp_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(WebDatabaseMigrationTest);
 };
 
-const int WebDatabaseMigrationTest::kCurrentTestedVersionNumber = 47;
+const int WebDatabaseMigrationTest::kCurrentTestedVersionNumber = 48;
 
 void WebDatabaseMigrationTest::LoadDatabase(const FilePath::StringType& file) {
   std::string contents;
   ASSERT_TRUE(GetWebDatabaseData(FilePath(file), &contents));
 
   sql::Connection connection;
   ASSERT_TRUE(connection.Open(GetDatabasePath()));
   ASSERT_TRUE(connection.Execute(contents.data()));
 }
 
@@ skipping 1219 matching lines @@
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
     // |keywords| |sync_guid| column should have been added.
     EXPECT_TRUE(connection.DoesColumnExist("keywords", "id"));
     EXPECT_TRUE(connection.DoesColumnExist("keywords", "sync_guid"));
   }
 }
 
-// Tests that the backup field for the default search provider gets added to
-// the meta table of a version 39 database.
+// Tests that no backup data is added to a version 39 database.
 TEST_F(WebDatabaseMigrationTest, MigrateVersion39ToCurrent) {
   // This schema is taken from a build prior to the addition of the default
   // search provider backup field to the meta table.
   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_39.sql")));
 
   // Verify pre-conditions.  These are expectations for version 39 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 39, 39));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_FALSE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                     &default_search_provider_id_backup));
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_FALSE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
+    EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 
   // Load the database via the WebDatabase class and migrate the database to
-  // the current version.
-  {
-    WebDatabase db;
-    ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    ASSERT_FALSE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
-  }
-
-  // Verify post-conditions.  These are expectations for current version of the
-  // database.
-  {
-    sql::Connection connection;
-    ASSERT_TRUE(connection.Open(GetDatabasePath()));
-    ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
-
-    // Check version.
-    EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
-
-    sql::MetaTable meta_table;
-    ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
-                                kCurrentTestedVersionNumber));
-
-    int64 default_search_provider_id = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
-                                    &default_search_provider_id));
-
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-    EXPECT_EQ(default_search_provider_id, default_search_provider_id_backup);
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-  }
-}
-
-#if !defined(GOOGLE_CHROME_BUILD)
-// Test that a valid backup is not overwritten during migration from version 39.
-// This is enabled on Chromium only because a valid signature is required for
-// this test, which makes it key-dependent.
-TEST_F(WebDatabaseMigrationTest, MigrateVersion39WithBackupToCurrent) {
-  // This schema is taken from a build prior to the addition of the default
-  // search provider backup field to the meta table.
-  ASSERT_NO_FATAL_FAILURE(
-      LoadDatabase(FILE_PATH_LITERAL("version_39_with_backup.sql")));
-
-  // Verify pre-conditions.  These are expectations for version 39 of the
-  // database.
-  {
-    sql::Connection connection;
-    ASSERT_TRUE(connection.Open(GetDatabasePath()));
-    ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
-
-    sql::MetaTable meta_table;
-    ASSERT_TRUE(meta_table.Init(&connection, 39, 39));
-
-    int64 default_search_provider_id = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
-                                    &default_search_provider_id));
-
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-    EXPECT_NE(default_search_provider_id, default_search_provider_id_backup);
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-  }
-
-  // Load the database via the WebDatabase class and migrate the database to
   // the current version.
   {
     WebDatabase db;
     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    // A change to the default search provider must be detected.
-    ASSERT_TRUE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
   }
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
                                 kCurrentTestedVersionNumber));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
+    EXPECT_NE(0, default_search_provider_id);
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-    EXPECT_NE(default_search_provider_id, default_search_provider_id_backup);
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
+    EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 }
-#endif  // !defined(GOOGLE_CHROME_BUILD)
 
-// Tests that the backup field for the default search provider is rewritten
-// despite any value in the old version.
+// Tests that the backup data is removed from the database.
 TEST_F(WebDatabaseMigrationTest, MigrateVersion40ToCurrent) {
-  // This schema is taken from a build after the addition of the default
-  // search provider backup field to the meta table. Due to crbug.com/101815
-  // the signature was empty in all build between revisions 106214 and 108111.
   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_40.sql")));
 
   // Verify pre-conditions.  These are expectations for version 40 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 40, 40));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-    EXPECT_TRUE(default_search_provider_id_backup_signature.empty());
+    EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
   }
 
   // Load the database via the WebDatabase class and migrate the database to
   // the current version.
   {
     WebDatabase db;
     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    ASSERT_FALSE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
   }
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
                                 kCurrentTestedVersionNumber));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
     EXPECT_NE(0, default_search_provider_id);
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-    EXPECT_EQ(default_search_provider_id, default_search_provider_id_backup);
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-    EXPECT_FALSE(default_search_provider_id_backup_signature.empty());
+    EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 }
 
-// Used to test that the default search provider was backed up and signed,
-// before the backup method was changed in version 43.
+// Tests that the backup data is removed from the database.
 TEST_F(WebDatabaseMigrationTest, MigrateVersion41ToCurrent) {
   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_41.sql")));
 
   // Verify pre-conditions.  These are expectations for version 41 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 41, 41));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-    EXPECT_FALSE(default_search_provider_id_backup_signature.empty());
+    EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
   }
 
   // Load the database via the WebDatabase class and migrate the database to
   // the current version.
   {
     WebDatabase db;
     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    ASSERT_FALSE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
   }
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
                                 kCurrentTestedVersionNumber));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
     EXPECT_NE(0, default_search_provider_id);
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-    EXPECT_EQ(default_search_provider_id, default_search_provider_id_backup);
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-    EXPECT_FALSE(default_search_provider_id_backup_signature.empty());
+    EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 }
 
-// Tests that all keywords are backed up and signed.
+// Tests that the backup data is removed from the database.
 TEST_F(WebDatabaseMigrationTest, MigrateVersion42ToCurrent) {
   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_42.sql")));
 
   // Verify pre-conditions.  These are expectations for version 42 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 42, 42));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-    EXPECT_FALSE(default_search_provider_id_backup_signature.empty());
+    EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
 
     EXPECT_FALSE(connection.DoesTableExist("keywords_backup"));
   }
 
   // Load the database via the WebDatabase class and migrate the database to
   // the current version.
   {
     WebDatabase db;
     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    ASSERT_FALSE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
   }
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
                                 kCurrentTestedVersionNumber));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
     EXPECT_NE(0, default_search_provider_id);
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-    EXPECT_EQ(default_search_provider_id, default_search_provider_id_backup);
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-    EXPECT_FALSE(default_search_provider_id_backup_signature.empty());
-
-    EXPECT_TRUE(connection.DoesTableExist("keywords_backup"));
-    std::string query("SELECT " + KeywordTable::GetKeywordColumns() +
-                      " FROM keywords_backup");
-    sql::Statement s(connection.GetUniqueStatement(query.c_str()));
-    ASSERT_TRUE(s.Step());
-    EXPECT_EQ(2, s.ColumnInt(0));
-    EXPECT_EQ("Google", s.ColumnString(1));
-    EXPECT_EQ("google.com", s.ColumnString(2));
-    EXPECT_EQ("http://www.google.com/favicon.ico", s.ColumnString(3));
-    EXPECT_EQ("{google:baseURL}search?{google:RLZ}{google:acceptedSuggestion}"
-              "{google:originalQueryForSuggestion}sourceid=chrome&"
-              "ie={inputEncoding}&q={searchTerms}",
-              s.ColumnString(4));
-    EXPECT_TRUE(s.ColumnBool(5));
-    EXPECT_EQ(std::string(), s.ColumnString(6));
-    EXPECT_EQ(0, s.ColumnInt(7));
-    EXPECT_EQ(0, s.ColumnInt(8));
-    EXPECT_EQ("UTF-8", s.ColumnString(9));
-    EXPECT_TRUE(s.ColumnBool(10));
-    EXPECT_EQ("{google:baseSuggestURL}search?client=chrome&hl={language}&"
-              "q={searchTerms}", s.ColumnString(11));
-    EXPECT_EQ(1, s.ColumnInt(12));
-    //EXPECT_EQ(false, s.ColumnBool(13));
-    EXPECT_EQ("{google:baseURL}webhp?{google:RLZ}sourceid=chrome-instant&"
-              "ie={inputEncoding}&ion=1{searchTerms}&nord=1",
-              s.ColumnString(14));
-    EXPECT_EQ(0, s.ColumnInt(15));
-    EXPECT_EQ("{1234-5678-90AB-CDEF}", s.ColumnString(16));
-
-    EXPECT_FALSE(s.Step());
+    EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 }
 
-// Tests that the default search provider is backed up and signed.
+// Tests that the backup data is removed from the database.
 TEST_F(WebDatabaseMigrationTest, MigrateVersion43ToCurrent) {
   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_43.sql")));
 
   int64 previous_default_search_provider_id;
 
   // Verify pre-conditions.  These are expectations for version 43 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 43, 43));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
     EXPECT_NE(default_search_provider_id, 0);
     previous_default_search_provider_id = default_search_provider_id;
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-    EXPECT_NE(default_search_provider_id_backup, 0);
-
-    // Backup ID is invalid, signature is invalid as well.
-    EXPECT_NE(default_search_provider_id, default_search_provider_id_backup);
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-    EXPECT_FALSE(default_search_provider_id_backup_signature.empty());
+    EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
+    EXPECT_TRUE(connection.DoesTableExist("keywords_backup"));
   }
 
   // Load the database via the WebDatabase class and migrate the database to
   // the current version.
   {
     WebDatabase db;
     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    ASSERT_FALSE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
   }
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(
         &connection,
         kCurrentTestedVersionNumber,
         kCurrentTestedVersionNumber));
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
     // Default search provider ID should not change.
     EXPECT_EQ(previous_default_search_provider_id, default_search_provider_id);
 
-    int64 default_search_provider_id_backup = 0;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchIDBackupKey,
-                                    &default_search_provider_id_backup));
-    // Backup ID must be updated to match the old default search provider ID.
-    EXPECT_EQ(default_search_provider_id, default_search_provider_id_backup);
-
-    std::string default_search_provider_id_backup_signature;
-    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kBackupSignatureKey,
-        &default_search_provider_id_backup_signature));
-    EXPECT_FALSE(default_search_provider_id_backup_signature.empty());
+    EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 }
 
-#if !defined(GOOGLE_CHROME_BUILD)
 // Tests that the |autogenerate_keyword| and |logo_id| columns get removed from
 // the keyword table schema for a version 45 database.
-//
-// This is enabled on Chromium only because a valid signature is required for
-// this test, which makes it key-dependent.
 TEST_F(WebDatabaseMigrationTest, MigrateVersion44ToCurrent) {
   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_44.sql")));
 
   // Verify pre-conditions.  These are expectations for version 44 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 44, 44));
 
     ASSERT_TRUE(connection.DoesColumnExist("keywords", "autogenerate_keyword"));
     ASSERT_TRUE(connection.DoesColumnExist("keywords", "logo_id"));
   }
 
   // Load the database via the WebDatabase class and migrate the database to
   // the current version.
   {
     WebDatabase db;
     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    ASSERT_FALSE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
-
-    // The backup table should match the keyword table.
-    std::string keywords_contents;
-    EXPECT_TRUE(db.GetKeywordTable()->GetTableContents("keywords",
-        kCurrentTestedVersionNumber, &keywords_contents));
-    std::string keywords_backup_contents;
-    EXPECT_TRUE(db.GetKeywordTable()->GetTableContents("keywords_backup",
-        kCurrentTestedVersionNumber, &keywords_backup_contents));
-    EXPECT_EQ(keywords_contents, keywords_backup_contents);
   }
 
   // Verify post-conditions.  These are expectations for current version of the
-  // database.
-  {
-    sql::Connection connection;
-    ASSERT_TRUE(connection.Open(GetDatabasePath()));
-    ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
-
-    // Check version.
-    EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
-
-    sql::MetaTable meta_table;
-    ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
-                                kCurrentTestedVersionNumber));
-
-    // We should have removed this obsolete key.
-    std::string default_search_provider_backup;
-    EXPECT_FALSE(meta_table.GetValue("Default Search Provider Backup",
-                                     &default_search_provider_backup));
-
-    // Two columns should have been removed.
-    EXPECT_FALSE(connection.DoesColumnExist("keywords",
-                                            "autogenerate_keyword"));
-    EXPECT_FALSE(connection.DoesColumnExist("keywords", "logo_id"));
-  }
-}
-#endif  // !defined(GOOGLE_CHROME_BUILD)
-
-// Like MigrateVersion44ToCurrent above, but with a corrupt backup signature.
-// This should result in us dropping the backup table but successfully migrating
-// otherwise.
-//
-// Because this test doesn't rely on a valid signature, we can run it on
-// official builds as well.
-TEST_F(WebDatabaseMigrationTest, MigrateVersion44CorruptBackupToCurrent) {
-  ASSERT_NO_FATAL_FAILURE(
-      LoadDatabase(FILE_PATH_LITERAL("version_44_backup_corrupt.sql")));
-
-  // Verify pre-conditions.  These are expectations for version 44 of the
-  // database.
-  {
-    sql::Connection connection;
-    ASSERT_TRUE(connection.Open(GetDatabasePath()));
-    ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
-
-    sql::MetaTable meta_table;
-    ASSERT_TRUE(meta_table.Init(&connection, 44, 44));
-
-    ASSERT_TRUE(connection.DoesColumnExist("keywords", "autogenerate_keyword"));
-    ASSERT_TRUE(connection.DoesColumnExist("keywords", "logo_id"));
-  }
-
-  // Load the database via the WebDatabase class and migrate the database to
-  // the current version.
-  {
-    WebDatabase db;
-    ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    // We should detect a "search provider change" as a side effect of dropping
-    // the backup table.
-    ASSERT_TRUE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
-  }
-
-  // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
                                 kCurrentTestedVersionNumber));
 
     // We should have removed this obsolete key.
     std::string default_search_provider_backup;
     EXPECT_FALSE(meta_table.GetValue("Default Search Provider Backup",
                                      &default_search_provider_backup));
 
     // Two columns should have been removed.
     EXPECT_FALSE(connection.DoesColumnExist("keywords",
                                             "autogenerate_keyword"));
     EXPECT_FALSE(connection.DoesColumnExist("keywords", "logo_id"));
 
-    // The backup table should be gone.
-    EXPECT_FALSE(connection.DoesTableExist("keywords_backup"));
+    // Backup data should have been removed.
+    EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 }
 
 // Tests that the web_intents and web_intents_defaults tables are
 // modified to include "scheme" columns.
 TEST_F(WebDatabaseMigrationTest, MigrateVersion45ToCurrent) {
   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_45.sql")));
 
   // Verify pre-conditions.  These are expectations for version 45 of the
   // database.
@@ skipping 169 matching lines @@
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
     EXPECT_LE(45, VersionFromConnection(&connection));
   }
 }
 
-#if !defined(GOOGLE_CHROME_BUILD)
 // Tests that the |alternate_urls| column is added to the keyword table schema
 // for a version 47 database.
-//
-// This is enabled on Chromium only because a valid signature is required for
-// this test, which makes it key-dependent.
 TEST_F(WebDatabaseMigrationTest, MigrateVersion46ToCurrent) {
   ASSERT_NO_FATAL_FAILURE(
       LoadDatabase(FILE_PATH_LITERAL("version_46.sql")));
 
   // Verify pre-conditions.  These are expectations for version 46 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 46, 46));
 
     ASSERT_FALSE(connection.DoesColumnExist("keywords", "alternate_urls"));
     ASSERT_FALSE(connection.DoesColumnExist("keywords_backup",
                                             "alternate_urls"));
   }
 
   // Load the database via the WebDatabase class and migrate the database to
   // the current version.
   {
     WebDatabase db;
     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    ASSERT_FALSE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
   }
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
     // A new column should have been created.
     EXPECT_TRUE(connection.DoesColumnExist("keywords", "alternate_urls"));
-    ASSERT_TRUE(connection.DoesColumnExist("keywords_backup",
-                                           "alternate_urls"));
   }
 }
-#endif  // !defined(GOOGLE_CHROME_BUILD)
 
-// Like MigrateVersion46ToCurrent above, but with a corrupt backup signature.
-// This should result in us dropping the backup table but successfully migrating
-// otherwise.
-//
-// Because this test doesn't rely on a valid signature, we can run it on
-// official builds as well.
-TEST_F(WebDatabaseMigrationTest, MigrateVersion46CorruptBackupToCurrent) {
-  ASSERT_NO_FATAL_FAILURE(
-      LoadDatabase(FILE_PATH_LITERAL("version_46_backup_corrupt.sql")));
+// Tests that the backup data is removed from the database.
+TEST_F(WebDatabaseMigrationTest, MigrateVersion47ToCurrent) {
+  ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_47.sql")));
 
-  // Verify pre-conditions.  These are expectations for version 46 of the
+  // Verify pre-conditions.  These are expectations for version 47 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
-    ASSERT_TRUE(meta_table.Init(&connection, 46, 46));
+    ASSERT_TRUE(meta_table.Init(&connection, 47, 47));
 
-    ASSERT_FALSE(connection.DoesColumnExist("keywords", "alternate_urls"));
-    ASSERT_FALSE(connection.DoesColumnExist("keywords_backup",
-                                            "alternate_urls"));
+    int64 default_search_provider_id = 0;
+    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
+                                    &default_search_provider_id));
+    EXPECT_NE(0, default_search_provider_id);
+
+    EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
+    EXPECT_TRUE(connection.DoesTableExist("keywords_backup"));
   }
 
   // Load the database via the WebDatabase class and migrate the database to
   // the current version.
   {
     WebDatabase db;
     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
-    // We should detect a "search provider change" as a side effect of dropping
-    // the backup table.
-    ASSERT_TRUE(db.GetKeywordTable()->DidDefaultSearchProviderChange());
   }
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
-    // A new column should have been created.
-    EXPECT_TRUE(connection.DoesColumnExist("keywords", "alternate_urls"));
+    sql::MetaTable meta_table;
+    ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
+                                kCurrentTestedVersionNumber));
 
-    // The backup table should be gone.
-    EXPECT_FALSE(connection.DoesTableExist("keywords_backup"));
+    int64 default_search_provider_id = 0;
+    EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
+                                    &default_search_provider_id));
+    EXPECT_NE(0, default_search_provider_id);
+
+    EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
   }
 }