Move creation of the various WebDatabaseTable types out of WebDatabase.

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"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/webdata/autofill_change.h"
 #include "chrome/browser/webdata/autofill_entry.h"
+#include "chrome/browser/webdata/autofill_table.h"
 #include "chrome/browser/webdata/keyword_table.h"
+#include "chrome/browser/webdata/logins_table.h"
+#include "chrome/browser/webdata/token_service_table.h"
+#include "chrome/browser/webdata/web_apps_table.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "chrome/browser/webdata/web_intents_table.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/autofill/browser/autofill_profile.h"
 #include "components/autofill/browser/autofill_type.h"
 #include "components/autofill/browser/credit_card.h"
 #include "content/public/test/test_browser_thread.h"
 #include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 127 matching lines @@
   // running on the DB thread.  Once that verification is added, this code will
   // need to be updated to create both threads.
   WebDatabaseMigrationTest()
       : ui_thread_(BrowserThread::UI, &message_loop_for_ui_) {}
   virtual ~WebDatabaseMigrationTest() {}
 
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
+  // Load the database via the WebDatabase class and migrate the database to
+  // the current version.
+  void DoMigration() {
+    // TODO(joi): This whole unit test file needs to stay in //chrome

[dhollowa, 2013/03/12 21:29:38]

Is there a bug to track this?  Need one?

[Jói, 2013/03/12 21:59:53]

Just the overall "Componentize WebData" bug (http://crbug.com/181277) which I
think is sufficient as we go through TODOs in code related to the component
before we close out such bugs.

+    // for now, as it needs to know about all the different table
+    // types. Once all webdata datatypes have been componentized, this
+    // could move to components_unittests.
+    AutofillTable autofill_table;
+    KeywordTable keyword_table;
+    LoginsTable logins_table;
+    TokenServiceTable token_service_table;
+    WebAppsTable web_apps_table;
+    WebIntentsTable web_intents_table;
+
+    WebDatabase db;
+    db.AddTable(&autofill_table);
+    db.AddTable(&keyword_table);
+    db.AddTable(&logins_table);
+    db.AddTable(&token_service_table);
+    db.AddTable(&web_apps_table);
+    db.AddTable(&web_intents_table);
+
+    // This causes the migration to occur.
+    ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath(), std::string()));
+  }
+
  protected:
   // Current tested version number.  When adding a migration in
   // |WebDatabase::MigrateOldVersionsAsNeeded()| and changing the version number
   // |kCurrentVersionNumber| this value should change to reflect the new version
   // number and a new migration test added below.
   static const int kCurrentTestedVersionNumber;
 
   base::FilePath GetDatabasePath() {
     const base::FilePath::CharType kWebDatabaseFilename[] =
         FILE_PATH_LITERAL("TestWebDatabase.sqlite3");
@@ skipping 43 matching lines @@
   std::string contents;
   ASSERT_TRUE(GetWebDatabaseData(base::FilePath(file), &contents));
 
   sql::Connection connection;
   ASSERT_TRUE(connection.Open(GetDatabasePath()));
   ASSERT_TRUE(connection.Execute(contents.data()));
 }
 
 // Tests that the all migrations from an empty database succeed.
 TEST_F(WebDatabaseMigrationTest, MigrateEmptyToCurrent) {
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 26 matching lines @@
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // No |credit_card| table prior to version 23.
     ASSERT_FALSE(connection.DoesColumnExist("credit_cards", "guid"));
     ASSERT_FALSE(
         connection.DoesColumnExist("credit_cards", "card_number_encrypted"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 22 matching lines @@
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Columns existing and not existing before current version.
     ASSERT_TRUE(connection.DoesColumnExist("credit_cards", "unique_id"));
     ASSERT_TRUE(
         connection.DoesColumnExist("credit_cards", "card_number_encrypted"));
     ASSERT_TRUE(connection.DoesColumnExist("keywords", "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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 14 matching lines @@
   // |created_by_policy| column.
   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_25.sql")));
 
   // Verify pre-conditions.  These are expectations for version 25 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 37 matching lines @@
     sql::Statement s2(connection.GetUniqueStatement(stmt2.c_str()));
     ASSERT_TRUE(s2.Run());
 
     // |billing_address| is a string.
     std::string stmt3 = "SELECT billing_address FROM credit_cards";
     sql::Statement s3(connection.GetUniqueStatement(stmt3.c_str()));
     ASSERT_TRUE(s3.Step());
     EXPECT_EQ(s3.ColumnType(0), sql::COLUMN_TYPE_TEXT);
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "billing_address"));
@@ skipping 44 matching lines @@
     sql::Statement s2(connection.GetUniqueStatement(stmt2.c_str()));
     ASSERT_TRUE(s2.Run());
 
     // |billing_address| is a string.
     std::string stmt3 = "SELECT billing_address FROM credit_cards";
     sql::Statement s3(connection.GetUniqueStatement(stmt3.c_str()));
     ASSERT_TRUE(s3.Step());
     EXPECT_EQ(s3.ColumnType(0), sql::COLUMN_TYPE_TEXT);
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 23 matching lines @@
 
   // Verify pre-conditions. These are expectations for version 27 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     ASSERT_FALSE(connection.DoesColumnExist("keywords", "instant_url"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 47 matching lines @@
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles",
                                             "date_modified"));
     EXPECT_FALSE(connection.DoesColumnExist("credit_cards",
                                             "date_modified"));
   }
 
-  // Load the database via the WebDatabase class and migrate the database to
-  // the current version.
   Time pre_creation_time = Time::Now();
-  {
-    WebDatabase db;
-    ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath(), std::string()));
-  }
+  DoMigration();
   Time post_creation_time = Time::Now();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
@@ skipping 36 matching lines @@
   // Verify pre-conditions. These are expectations for version 29 of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "guid"));
     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "guid"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 76 matching lines @@
                                                       &credit_card,
                                                       &cc_label,
                                                       &cc_unique_id,
                                                       &cc_number_encrypted,
                                                       &cc_date_modified));
 
     EXPECT_NE(profile_unique_id, cc_unique_id);
     EXPECT_NE(profile.guid(), credit_card.guid());
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 97 matching lines @@
     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
                                            "date_modified"));
 
     EXPECT_FALSE(connection.DoesTableExist("autofill_profile_names"));
     EXPECT_FALSE(connection.DoesTableExist("autofill_profile_emails"));
     EXPECT_FALSE(connection.DoesTableExist("autofill_profile_phones"));
 
     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "label"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 259 matching lines @@
 
     // Check that the country value is the one we expect.
     sql::Statement s(
         connection.GetUniqueStatement("SELECT country FROM autofill_profiles"));
 
     ASSERT_TRUE(s.Step());
     std::string country = s.ColumnString(0);
     EXPECT_EQ("United States", country);
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 30 matching lines @@
                                       "FROM autofill_profiles"));
 
     ASSERT_TRUE(s.Step());
     std::string country_code = s.ColumnString(0);
     EXPECT_EQ("UK", country_code);
 
     // Should have only one.
     ASSERT_FALSE(s.Step());
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 31 matching lines @@
 
     // Check that there are 6 profiles prior to merge.
     sql::Statement s(
         connection.GetUniqueStatement("SELECT guid FROM autofill_profiles"));
     int i = 0;
     while (s.Step())
       ++i;
     EXPECT_EQ(6, i);
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 58 matching lines @@
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Columns existing and not existing before current version.
     ASSERT_TRUE(connection.DoesColumnExist("keywords", "id"));
     ASSERT_FALSE(connection.DoesColumnExist("keywords", "last_modified"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 14 matching lines @@
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Columns existing and not existing before current version.
     ASSERT_TRUE(connection.DoesColumnExist("keywords", "id"));
     ASSERT_FALSE(connection.DoesColumnExist("keywords", "sync_guid"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // Verify post-conditions.  These are expectations for current version of the
   // database.
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 
     // Check version.
     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 
@@ skipping 19 matching lines @@
     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));
 
     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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 25 matching lines @@
     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));
 
     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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 25 matching lines @@
     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));
 
     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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 27 matching lines @@
 
     int64 default_search_provider_id = 0;
     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
                                     &default_search_provider_id));
 
     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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 30 matching lines @@
     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;
 
     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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 26 matching lines @@
     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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 30 matching lines @@
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 45, 45));
 
     ASSERT_FALSE(connection.DoesColumnExist("scheme", "web_intents"));
     ASSERT_FALSE(connection.DoesColumnExist(
         "scheme", "web_intents_defaults"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 55 matching lines @@
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 45, 45));
 
     ASSERT_FALSE(connection.DoesColumnExist("scheme", "web_intents"));
     ASSERT_FALSE(connection.DoesColumnExist(
         "scheme", "web_intents_defaults"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 39 matching lines @@
   {
     sql::Connection connection;
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     // Database is actually version 45 but the version field states 40.
     ASSERT_TRUE(meta_table.Init(&connection, 40, 45));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 15 matching lines @@
     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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 19 matching lines @@
 
     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(), std::string()));
-  }
+  DoMigration();
 
   // 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));
@@ skipping 24 matching lines @@
     ASSERT_TRUE(connection.Open(GetDatabasePath()));
     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
 
     sql::MetaTable meta_table;
     ASSERT_TRUE(meta_table.Init(&connection, 48, 48));
 
     ASSERT_FALSE(connection.DoesColumnExist("keywords",
                                             "search_terms_replacement_key"));
   }
 
-  // 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(), std::string()));
-  }
+  DoMigration();
 
   // 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",
                                            "search_terms_replacement_key"));
   }
 }