Add metrics for tracking LoginDatabase::Init failure.

components/password_manager/core/browser/login_database.cc

 // Copyright 2014 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/password_manager/core/browser/login_database.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/pickle.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/browser/affiliation_utils.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_urls.h"
@@ skipping 53 matching lines @@
   COLUMN_DATE_SYNCED,
   COLUMN_DISPLAY_NAME,
   COLUMN_AVATAR_URL,
   COLUMN_FEDERATION_URL,
   COLUMN_SKIP_ZERO_CLICK,
   COLUMN_GENERATION_UPLOAD_STATUS,
 };
 
 enum class HistogramSize { SMALL, LARGE };
 
+// An enum for UMA reporting. Add values to the end only.
+enum DatabaseInitError {
+  INIT_OK,
+  OPEN_FILE_ERROR,
+  START_TRANSACTION_ERROR,
+  META_TABLE_INIT_ERROR,
+  INCOMPATIBLE_VERSION,
+  INIT_LOGINS_ERROR,
+  INIT_STATS_ERROR,
+  MIGRATION_ERROR,
+  COMMIT_TRANSACTION_ERROR,
+
+  DATABASE_INIT_ERROR_COUNT,
+};
+
 void BindAddStatement(const PasswordForm& form,
                       const std::string& encrypted_password,
                       sql::Statement* s) {
   s->BindString(COLUMN_ORIGIN_URL, form.origin.spec());
   s->BindString(COLUMN_ACTION_URL, form.action.spec());
   s->BindString16(COLUMN_USERNAME_ELEMENT, form.username_element);
   s->BindString16(COLUMN_USERNAME_VALUE, form.username_value);
   s->BindString16(COLUMN_PASSWORD_ELEMENT, form.password_element);
   s->BindBlob(COLUMN_PASSWORD_VALUE, encrypted_password.data(),
               static_cast<int>(encrypted_password.length()));
@@ skipping 34 matching lines @@
     DLOG(ERROR) << "Constraint violation: form.origin is empty";
     return false;
   }
   if (form.signon_realm.empty()) {
     DLOG(ERROR) << "Constraint violation: form.signon_realm is empty";
     return false;
   }
   return true;
 }
 
+void LogDatabaseInitError(DatabaseInitError error) {
+  UMA_HISTOGRAM_ENUMERATION("PasswordManager.LoginDatabaseInit", error,
+                            DATABASE_INIT_ERROR_COUNT);
+}
+
 // UMA_* macros assume that the name never changes. This is a helper function
 // where this assumption doesn't hold.
 void LogDynamicUMAStat(const std::string& name,
                        int sample,
                        int min,
                        int max,
                        int bucket_count) {
   base::HistogramBase* counter = base::Histogram::FactoryGet(
       name, min, max, bucket_count,
       base::HistogramBase::kUmaTargetedHistogramFlag);
@@ skipping 139 matching lines @@
 
 bool LoginDatabase::Init() {
   // Set pragmas for a small, private database (based on WebDatabase).
   db_.set_page_size(2048);
   db_.set_cache_size(32);
   db_.set_exclusive_locking();
   db_.set_restrict_to_user();
   db_.set_histogram_tag("Passwords");
 
   if (!db_.Open(db_path_)) {
+    LogDatabaseInitError(OPEN_FILE_ERROR);
     LOG(ERROR) << "Unable to open the password store database.";
     return false;
   }
 
   sql::Transaction transaction(&db_);
   if (!transaction.Begin()) {
+    LogDatabaseInitError(START_TRANSACTION_ERROR);
     LOG(ERROR) << "Unable to start a transaction.";
     db_.Close();
     return false;
   }
 
   // Check the database version.
   if (!meta_table_.Init(&db_, kCurrentVersionNumber,
                         kCompatibleVersionNumber)) {
+    LogDatabaseInitError(META_TABLE_INIT_ERROR);
     LOG(ERROR) << "Unable to create the meta table.";
     db_.Close();
     return false;
   }
   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
+    LogDatabaseInitError(INCOMPATIBLE_VERSION);
     LOG(ERROR) << "Password store database is too new, kCurrentVersionNumber="
                << kCurrentVersionNumber << ", GetCompatibleVersionNumber="
                << meta_table_.GetCompatibleVersionNumber();
     db_.Close();
     return false;
   }
 
   // Initialize the tables.
   if (!InitLoginsTable()) {
+    LogDatabaseInitError(INIT_LOGINS_ERROR);
     LOG(ERROR) << "Unable to initialize the logins table.";
     db_.Close();
     return false;
   }
 
   if (!stats_table_.Init(&db_)) {
+    LogDatabaseInitError(INIT_STATS_ERROR);
     LOG(ERROR) << "Unable to initialize the stats table.";
     db_.Close();
     return false;
   }
 
   // If the file on disk is an older database version, bring it up to date.
   if (!MigrateOldVersionsAsNeeded()) {
+    LogDatabaseInitError(MIGRATION_ERROR);
+    UMA_HISTOGRAM_SPARSE_SLOWLY("PasswordManager.LoginDatabaseFailedVersion",
+                                meta_table_.GetVersionNumber());
     LOG(ERROR) << "Unable to migrate database from "
                << meta_table_.GetVersionNumber() << " to "
                << kCurrentVersionNumber;
     db_.Close();
     return false;
   }
 
   if (!transaction.Commit()) {
+    LogDatabaseInitError(COMMIT_TRANSACTION_ERROR);
     LOG(ERROR) << "Unable to commit a transaction.";
     db_.Close();
     return false;
   }
 
+  LogDatabaseInitError(INIT_OK);
   return true;
 }
 
 bool LoginDatabase::MigrateOldVersionsAsNeeded() {
   switch (meta_table_.GetVersionNumber()) {
     case 1:
       if (!db_.Execute("ALTER TABLE logins "
                        "ADD COLUMN password_type INTEGER") ||
           !db_.Execute("ALTER TABLE logins "
                        "ADD COLUMN possible_usernames BLOB")) {
@@ skipping 750 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               psl_domain_match_metric, PSL_DOMAIN_MATCH_COUNT);
   }
 
   if (!statement->Succeeded())
     return false;
   return true;
 }
 
 }  // namespace password_manager