History init: add metrics and skip migration.

components/history/core/browser/history_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/history/core/browser/history_database.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 24 matching lines @@
 namespace {
 
 // Current version number. We write databases at the "current" version number,
 // but any previous version that can read the "compatible" one can make do with
 // our database without *too* many bad effects.
 const int kCurrentVersionNumber = 36;
 const int kCompatibleVersionNumber = 16;
 const char kEarlyExpirationThresholdKey[] = "early_expiration_threshold";
 const int kMaxHostsInMemory = 10000;
 
+// Logs a migration failure to UMA and logging. The return value will be
+// what to return from ::Init (to simplify the call sites). Migration failures
+// are almost always fatal since the database can be in an inconsistent state.
+sql::InitStatus LogMigrationFailure(int from_version) {
+  UMA_HISTOGRAM_SPARSE_SLOWLY("History.MigrateFailureFromVersion",
+                              from_version);
+  LOG(ERROR) << "History failed to migrate from version " << from_version
+             << ". History will be disabled.";
+  return sql::INIT_FAILURE;
+}
+
+// Reasons for initialization to fail. These are logged to UMA. It corresponds
+// to the HistoryInitStep enum in enums.xml.
+//
+// DO NOT CHANGE THE VALUES. Leave holes if anything is removed and add only
+// to the end.
+enum class InitStep {
+  OPEN = 0,
+  TRANSACTION_BEGIN,
+  META_TABLE_INIT,
+  CREATE_TABLES,
+  VERSION,
+  COMMIT,
+};
+
+sql::InitStatus LogInitFailure(InitStep what) {
+  UMA_HISTOGRAM_SPARSE_SLOWLY("History.InitializationFailureStep",
+                              static_cast<int>(what));
+  return sql::INIT_FAILURE;
+}
+
 }  // namespace
 
 HistoryDatabase::HistoryDatabase(
     DownloadInterruptReason download_interrupt_reason_none,
     DownloadInterruptReason download_interrupt_reason_crash)
     : DownloadDatabase(download_interrupt_reason_none,
                        download_interrupt_reason_crash) {
 }
 
 HistoryDatabase::~HistoryDatabase() {
@@ skipping 12 matching lines @@
   // value, tells us how much memory the cache will use maximum.
   // 1000 * 4kB = 4MB
   // TODO(brettw) scale this value to the amount of available memory.
   db_.set_cache_size(1000);
 
   // Note that we don't set exclusive locking here. That's done by
   // BeginExclusiveMode below which is called later (we have to be in shared
   // mode to start out for the in-memory backend to read the data).
 
   if (!db_.Open(history_name))
-    return sql::INIT_FAILURE;
+    return LogInitFailure(InitStep::OPEN);
 
   // Wrap the rest of init in a tranaction. This will prevent the database from
   // getting corrupted if we crash in the middle of initialization or migration.
   sql::Transaction committer(&db_);
   if (!committer.Begin())
-    return sql::INIT_FAILURE;
+    return LogInitFailure(InitStep::TRANSACTION_BEGIN);
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   // Exclude the history file from backups.
   base::mac::SetFileBackupExclusion(history_name);
 #endif
 
   // Prime the cache.
   db_.Preload();
 
   // Create the tables and indices.
   // NOTE: If you add something here, also add it to
   //       RecreateAllButStarAndURLTables.
   if (!meta_table_.Init(&db_, GetCurrentVersion(), kCompatibleVersionNumber))
-    return sql::INIT_FAILURE;
+    return LogInitFailure(InitStep::META_TABLE_INIT);
   if (!CreateURLTable(false) || !InitVisitTable() ||
       !InitKeywordSearchTermsTable() || !InitDownloadTable() ||
       !InitSegmentTables() || !InitSyncTable())
-    return sql::INIT_FAILURE;
+    return LogInitFailure(InitStep::CREATE_TABLES);
   CreateMainURLIndex();
   CreateKeywordSearchTermsIndices();
 
   // TODO(benjhayden) Remove at some point.
   meta_table_.DeleteKey("next_download_id");
 
   // Version check.
   sql::InitStatus version_status = EnsureCurrentVersion();
-  if (version_status != sql::INIT_OK)
+  if (version_status != sql::INIT_OK) {
+    LogInitFailure(InitStep::VERSION);
     return version_status;
+  }
 
-  return committer.Commit() ? sql::INIT_OK : sql::INIT_FAILURE;
+  if (!committer.Commit())
+    return LogInitFailure(InitStep::COMMIT);
+  return sql::INIT_OK;
 }
 
 void HistoryDatabase::ComputeDatabaseMetrics(
     const base::FilePath& history_name) {
   base::TimeTicks start_time = base::TimeTicks::Now();
   int64_t file_size = 0;
   if (!base::GetFileSize(history_name, &file_size))
     return;
   int file_mb = static_cast<int>(file_size / (1024 * 1024));
   UMA_HISTOGRAM_MEMORY_MB("History.DatabaseFileMB", file_mb);
@@ skipping 252 matching lines @@
   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
     LOG(WARNING) << "History database is too new.";
     return sql::INIT_TOO_NEW;
   }
 
   int cur_version = meta_table_.GetVersionNumber();
 
   // Put migration code here
 
   if (cur_version == 15) {
-    if (!db_.Execute("DROP TABLE starred") || !DropStarredIDFromURLs()) {
-      LOG(WARNING) << "Unable to update history database to version 16.";
-      return sql::INIT_FAILURE;
-    }
+    if (!db_.Execute("DROP TABLE starred") || !DropStarredIDFromURLs())
+      return LogMigrationFailure(15);
     ++cur_version;
     meta_table_.SetVersionNumber(cur_version);
     meta_table_.SetCompatibleVersionNumber(
         std::min(cur_version, kCompatibleVersionNumber));
   }
 
   if (cur_version == 16) {
 #if !defined(OS_WIN)
     // In this version we bring the time format on Mac & Linux in sync with the
     // Windows version so that profiles can be moved between computers.
@@ skipping 23 matching lines @@
 
   if (cur_version == 19) {
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
     // This was the thumbnail migration.  Obsolete.
   }
 
   if (cur_version == 20) {
     // This is the version prior to adding the visit_duration field in visits
     // database. We need to migrate the database.
-    if (!MigrateVisitsWithoutDuration()) {
-      LOG(WARNING) << "Unable to update history database to version 21.";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateVisitsWithoutDuration())
+      return LogMigrationFailure(20);
     ++cur_version;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 21) {
     // The android_urls table's data schemal was changed in version 21.
 #if defined(OS_ANDROID)
-    if (!MigrateToVersion22()) {
-      LOG(WARNING) << "Unable to migrate the android_urls table to version 22";
-    }
+    if (!MigrateToVersion22())
+      return LogMigrationFailure(21);
 #endif
     ++cur_version;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 22) {
-    if (!MigrateDownloadsState()) {
-      LOG(WARNING) << "Unable to fix invalid downloads state values";
-      // Invalid state values may cause crashes.
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateDownloadsState())
+      return LogMigrationFailure(22);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 23) {
-    if (!MigrateDownloadsReasonPathsAndDangerType()) {
-      LOG(WARNING) << "Unable to upgrade download interrupt reason and paths";
-      // Invalid state values may cause crashes.
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateDownloadsReasonPathsAndDangerType())
+      return LogMigrationFailure(23);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 24) {
-    if (!MigratePresentationIndex()) {
-      LOG(WARNING) << "Unable to migrate history to version 25";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigratePresentationIndex())
+      return LogMigrationFailure(24);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 25) {
-    if (!MigrateReferrer()) {
-      LOG(WARNING) << "Unable to migrate history to version 26";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateReferrer())
+      return LogMigrationFailure(25);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 26) {
-    if (!MigrateDownloadedByExtension()) {
-      LOG(WARNING) << "Unable to migrate history to version 27";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateDownloadedByExtension())
+      return LogMigrationFailure(26);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 27) {
-    if (!MigrateDownloadValidators()) {
-      LOG(WARNING) << "Unable to migrate history to version 28";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateDownloadValidators())
+      return LogMigrationFailure(27);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 28) {
-    if (!MigrateMimeType()) {
-      LOG(WARNING) << "Unable to migrate history to version 29";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateMimeType())
+      return LogMigrationFailure(28);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 29) {
-    if (!MigrateHashHttpMethodAndGenerateGuids()) {
-      LOG(WARNING) << "Unable to migrate history to version 30";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateHashHttpMethodAndGenerateGuids())
+      return LogMigrationFailure(29);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 30) {
-    if (!MigrateDownloadTabUrl()) {
-      LOG(WARNING) << "Unable to migrate history to version 31";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateDownloadTabUrl())
+      return LogMigrationFailure(30);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 31) {
-    if (!MigrateDownloadSiteInstanceUrl()) {
-      LOG(WARNING) << "Unable to migrate history to version 32";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateDownloadSiteInstanceUrl())
+      return LogMigrationFailure(31);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 32) {
     // New download slices table is introduced, no migration needed.
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 33) {
-    if (!MigrateDownloadLastAccessTime()) {
-      LOG(WARNING) << "Unable to migrate to version 34";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateDownloadLastAccessTime())
+      return LogMigrationFailure(33);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 34) {
+    /*
+    This code is commented out because we suspect the additional disk storage
+    requirements of duplicating the URL table to update the schema cause
+    some devices to run out of storage. Errors during initialization are
+    very disruptive to the user experience.
+
+    TODO(https://crbug.com/736136) figure out how to update users to use
+    AUTOINCREMENT.
+
     // AUTOINCREMENT is added to urls table PRIMARY KEY(id), need to recreate a
     // new table and copy all contents over. favicon_id is removed from urls
     // table since we never use it. Also typed_url_sync_metadata and
     // autofill_model_type_state tables are introduced, no migration needed for
     // those two tables.
-    if (!RecreateURLTableWithAllContents()) {
-      LOG(WARNING) << "Unable to update history database to version 35.";
-      return sql::INIT_FAILURE;
-    }
+    if (!RecreateURLTableWithAllContents())
+      return LogMigrationFailure(34);
+    */
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
   if (cur_version == 35) {
-    if (!MigrateDownloadTransient()) {
-      LOG(WARNING) << "Unable to migrate to version 36";
-      return sql::INIT_FAILURE;
-    }
+    if (!MigrateDownloadTransient())
+      return LogMigrationFailure(35);
     cur_version++;
     meta_table_.SetVersionNumber(cur_version);
   }
 
+  // =========================       ^^ new migration code goes here ^^
+  // ADDING NEW MIGRATION CODE
+  // =========================
+  //
+  // Add new migration code above here. It's important to use as little space
+  // as possible during migration. Many phones are very near their storage
+  // limit, so anything that recreates or duplicates large history tables can
+  // easily push them over that limit.
+  //
+  // When failures happen during initialization, history is not loaded. This
+  // causes all components related to the history database file to fail
+  // completely, including autocomplete and downloads. Devices near their
+  // storage limit are likely to fail doing some update later, but those
+  // operations will then just be skipped which is not nearly as disruptive.
+  // See https://crbug.com/734194.
+
   // When the version is too old, we just try to continue anyway, there should
   // not be a released product that makes a database too old for us to handle.
   LOG_IF(WARNING, cur_version < GetCurrentVersion()) <<
          "History database version " << cur_version << " is too old to handle.";
 
   return sql::INIT_OK;
 }
 
 #if !defined(OS_WIN)
 void HistoryDatabase::MigrateTimeEpoch() {
   // Update all the times in the URLs and visits table in the main database.
   ignore_result(db_.Execute(
       "UPDATE urls "
       "SET last_visit_time = last_visit_time + 11644473600000000 "
       "WHERE id IN (SELECT id FROM urls WHERE last_visit_time > 0);"));
   ignore_result(db_.Execute(
       "UPDATE visits "
       "SET visit_time = visit_time + 11644473600000000 "
       "WHERE id IN (SELECT id FROM visits WHERE visit_time > 0);"));
   ignore_result(db_.Execute(
       "UPDATE segment_usage "
       "SET time_slot = time_slot + 11644473600000000 "
       "WHERE id IN (SELECT id FROM segment_usage WHERE time_slot > 0);"));
 }
 #endif
 
 }  // namespace history