Raze old WebDatabases.

components/webdata/common/web_database.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 "components/webdata/common/web_database.h"
 
 #include <algorithm>
 
 #include "base/stl_util.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 // Current version number.  Note: when changing the current version number,
 // corresponding changes must happen in the unit tests, and new migration test
 // added.  See |WebDatabaseMigrationTest::kCurrentTestedVersionNumber|.
 // static
 const int WebDatabase::kCurrentVersionNumber = 62;
 
+const int WebDatabase::kDeprecatedVersionNumber = 51;
+
 namespace {
 
 const int kCompatibleVersionNumber = 61;
 
 // Change the version number and possibly the compatibility version of
 // |meta_table_|.
 void ChangeVersion(sql::MetaTable* meta_table,
                    int version_num,
                    bool update_compatible_version_num) {
   meta_table->SetVersionNumber(version_num);
@@ skipping 51 matching lines @@
   // infrequent. So we go with a small cache size.
   db_.set_cache_size(32);
 
   // Run the database in exclusive mode. Nobody else should be accessing the
   // database while we're running, and this will give somewhat improved perf.
   db_.set_exclusive_locking();
 
   if (!db_.Open(db_name))
     return sql::INIT_FAILURE;
 
-  // Initialize various tables
+  // Clobber really old databases.
+  DCHECK_LT(kDeprecatedVersionNumber, kCurrentVersionNumber);

[Peter Kasting, 2015/02/26 22:33:19]

I don't know that this DCHECK is really needed.

[Evan Stade, 2015/02/26 22:37:19]

This is copied from TopSitesDatabase. I am ambivalent about its necessity
overall but I would like to be consistent.

[Scott Hess - ex-Googler, 2015/02/27 06:49:38]

The rationale was that if someone accidentally got it wrong, all of the
databases would be reset with no way to recover.  I don't think there was any
reason not to use a compile-time assertion, though.

Of course given appropriate test coverage this is completely redundant.  I wish
there were a way to assert "You can only use this if you're testing this edge".

[Peter Kasting, 2015/02/27 09:15:25]

I didn't even think of that.  Yes, please use a static_assert if keeping this,
that's safer.

[Evan Stade, 2015/02/28 00:13:41]

Done.

+  sql::MetaTable::RazeIfDeprecated(&db_, kDeprecatedVersionNumber);
+
+  // Scope initialization in a transaction so we can't be partially
+  // initialized.
   sql::Transaction transaction(&db_);
   if (!transaction.Begin())
     return sql::INIT_FAILURE;
 
   // Version check.
   if (!meta_table_.Init(&db_, kCurrentVersionNumber, kCompatibleVersionNumber))
     return sql::INIT_FAILURE;
   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
     LOG(WARNING) << "Web database is too new.";
     return sql::INIT_TOO_NEW;
@@ skipping 27 matching lines @@
 
 sql::InitStatus WebDatabase::MigrateOldVersionsAsNeeded() {
   // Some malware used to lower the version number, causing migration to
   // fail. Ensure the version number is at least as high as the compatible
   // version number.
   int current_version = std::max(meta_table_.GetVersionNumber(),
                                  meta_table_.GetCompatibleVersionNumber());
   if (current_version > meta_table_.GetVersionNumber())
     ChangeVersion(&meta_table_, current_version, false);
 
-  if (current_version < 20) {
-    // Versions 1 - 19 are unhandled.  Version numbers greater than
+  if (current_version < kDeprecatedVersionNumber) {

[Scott Hess - ex-Googler, 2015/02/27 06:49:38]

This case should not be possible anymore, right?

[Peter Kasting, 2015/02/27 09:15:25]

I think not; even if the user manually copies old DB files in after we raze
them, we'll just raze them again.  So this could probably become a DCHECK and
omit the rest of the block here.

[Evan Stade, 2015/02/28 00:13:41]

Done.

+    // Deprecated versions are unhandled.  Version numbers greater than
     // kCurrentVersionNumber should have already been weeded out by the caller.
     //
     // When the version is too old, we return failure error code.  The schema
     // is too out of date to migrate.
-    //
-    // There should not be a released product that makes a database too old to
-    // migrate. If we do encounter such a legacy database, we will need a
-    // better solution to handle it (i.e., pop up a dialog to tell the user,
-    // erase all their prefs and start over, etc.).
     LOG(WARNING) << "Web database version " << current_version
                  << " is too old to handle.";
-    NOTREACHED();
     return sql::INIT_FAILURE;
   }
 
   for (int next_version = current_version + 1;
        next_version <= kCurrentVersionNumber;
        ++next_version) {
 
     // Do any database-wide migrations.
     bool update_compatible_version = false;
     if (!MigrateToVersion(next_version, &update_compatible_version))
@@ skipping 30 matching lines @@
 
 bool WebDatabase::MigrateToVersion58DropWebAppsAndIntents() {
   sql::Transaction transaction(&db_);
   return transaction.Begin() &&
       db_.Execute("DROP TABLE IF EXISTS web_apps") &&
       db_.Execute("DROP TABLE IF EXISTS web_app_icons") &&
       db_.Execute("DROP TABLE IF EXISTS web_intents") &&
       db_.Execute("DROP TABLE IF EXISTS web_intents_defaults") &&
       transaction.Commit();
 }