[sql] Ship Favicons recovery code to beta and stable.

chrome/browser/history/thumbnail_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 "chrome/browser/history/thumbnail_database.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 365 matching lines @@
 // detected.  So this database is a good test subject.
 void RecoverDatabaseOrRaze(sql::Connection* db, const base::FilePath& db_path) {
   // NOTE(shess): This code is currently specific to the version
   // number.  I am working on simplifying things to loosen the
   // dependency, meanwhile contact me if you need to bump the version.
   DCHECK_EQ(7, kCurrentVersionNumber);
 
   // TODO(shess): Reset back after?
   db->reset_error_callback();
 
+  // For histogram purposes.
+  size_t favicons_rows_recovered = 0;
+  size_t favicon_bitmaps_rows_recovered = 0;
+  size_t icon_mapping_rows_recovered = 0;
+  int64 original_size = 0;
+  file_util::GetFileSize(db_path, &original_size);
+
   scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(db, db_path);
   if (!recovery) {
     // TODO(shess): Unable to create recovery connection.  This
     // implies something substantial is wrong.  At this point |db| has
     // been poisoned so there is nothing really to do.
     //
     // Possible responses are unclear.  If the failure relates to a
     // problem somehow specific to the temporary file used to back the
     // database, then an in-memory database could possibly be used.
     // This could potentially allow recovering the main database, and
@@ skipping 201 matching lines @@
   // issues with the tables?
   // - icon_mapping.icon_id maps to no favicons.id
   // - favicon_bitmaps.icon_id maps to no favicons.id
   // - favicons.id is referenced by no icon_mapping.icon_id
   // - favicons.id is referenced by no favicon_bitmaps.icon_id
   // This step is possibly not worth the effort necessary to develop
   // and sequence the statements, as it is basically a form of garbage
   // collection.
 
   ignore_result(sql::Recovery::Recovered(recovery.Pass()));
+
+  // Track the size of the recovered database relative to the size of
+  // the input database.  The size should almost always be smaller,
+  // unless the input database was empty to start with.  If the
+  // percentage results are very low, something is awry.
+  int64 final_size = 0;
+  if (original_size > 0 &&
+      file_util::GetFileSize(db_path, &final_size) &&
+      final_size > 0) {
+    int percentage = static_cast<int>(original_size * 100 / final_size);
+    UMA_HISTOGRAM_PERCENTAGE("History.FaviconsRecoveredPercentage",
+                             std::max(100, percentage));
+  }
+
+  // Using 10,000 because these cases mostly care about "none
+  // recovered" and "lots recovered".  More than 10,000 rows recovered
+  // probably means there's something wrong with the profile.
+  UMA_HISTOGRAM_COUNTS_10000("History.FaviconsRecoveredRowsFavicons",
+                             favicons_rows_recovered);
+  UMA_HISTOGRAM_COUNTS_10000("History.FaviconsRecoveredRowsFaviconBitmaps",
+                             favicon_bitmaps_rows_recovered);
+  UMA_HISTOGRAM_COUNTS_10000("History.FaviconsRecoveredRowsIconMapping",
+                             icon_mapping_rows_recovered);
+
   if (version == 6) {
     RecordRecoveryEvent(RECOVERY_EVENT_RECOVERED_VERSION6);
   } else {
     RecordRecoveryEvent(RECOVERY_EVENT_RECOVERED);
   }
 }
 
 void DatabaseErrorCallback(sql::Connection* db,
                            const base::FilePath& db_path,
                            size_t startup_kb,
                            int extended_error,
                            sql::Statement* stmt) {
   // TODO(shess): Assert that this is running on a safe thread.
   // AFAICT, should be the history thread, but at this level I can't
   // see how to reach that.
 
   // TODO(shess): For now, don't report on beta or stable so as not to
   // overwhelm the crash server.  Once the big fish are fried,
   // consider reporting at a reduced rate on the bigger channels.
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel != chrome::VersionInfo::CHANNEL_STABLE &&
       channel != chrome::VersionInfo::CHANNEL_BETA) {
     GenerateDiagnostics(db, startup_kb, extended_error);
   }
 
   // Attempt to recover corrupt databases.
-  // TODO(shess): Remove the channel restriction once it becomes clear
-  // that the recovery code fails gracefully.
-  if (channel != chrome::VersionInfo::CHANNEL_STABLE &&
-      channel != chrome::VersionInfo::CHANNEL_BETA) {
-    int error = (extended_error & 0xFF);
-    if (error == SQLITE_CORRUPT ||
-        error == SQLITE_CANTOPEN ||
-        error == SQLITE_NOTADB) {
-      RecoverDatabaseOrRaze(db, db_path);
-    }
+  int error = (extended_error & 0xFF);
+  if (error == SQLITE_CORRUPT ||
+      error == SQLITE_CANTOPEN ||
+      error == SQLITE_NOTADB) {
+    RecoverDatabaseOrRaze(db, db_path);
   }
 
   // The default handling is to assert on debug and to ignore on release.
   if (!sql::Connection::ShouldIgnoreSqliteError(extended_error))
     DLOG(FATAL) << db->GetErrorMessage();
 }
 
 }  // namespace
 
 namespace history {
@@ skipping 739 matching lines @@
   meta_table_.SetVersionNumber(7);
   meta_table_.SetCompatibleVersionNumber(std::min(7, kCompatibleVersionNumber));
   return true;
 }
 
 bool ThumbnailDatabase::IsFaviconDBStructureIncorrect() {
   return !db_.IsSQLValid("SELECT id, url, icon_type FROM favicons");
 }
 
 }  // namespace history