[Password Manager] Add UMA stats for custom passphrase users.

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.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/password_manager_client.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using autofill::PasswordForm;
 
 namespace password_manager {
 
@@ skipping 80 matching lines @@
   s->BindString(COLUMN_AVATAR_URL, form.avatar_url.spec());
   s->BindString(COLUMN_FEDERATION_URL, form.federation_url.spec());
   s->BindInt(COLUMN_IS_ZERO_CLICK, form.is_zero_click);
 }
 
 void AddCallback(int err, sql::Statement* /*stmt*/) {
   if (err == 19 /*SQLITE_CONSTRAINT*/)
     DLOG(WARNING) << "LoginDatabase::AddLogin updated an existing form";
 }
 
+// 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_size) {
+  base::HistogramBase* counter = base::Histogram::FactoryGet(
+      name,
+      min,
+      max,
+      bucket_size,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  counter->Add(sample);
+}
+
+void LogAccountStat(const std::string& name, int sample) {
+  LogDynamicUMAStat(name, sample, 0, 32, 6);
+}
+
+void LogTimesUsedStat(const std::string& name, int sample) {
+  LogDynamicUMAStat(name, sample, 0, 100, 10);
+}
+
 }  // namespace
 
 LoginDatabase::LoginDatabase() {
 }
 
 LoginDatabase::~LoginDatabase() {
 }
 
 bool LoginDatabase::Init(const base::FilePath& db_path) {
   // Set pragmas for a small, private database (based on WebDatabase).
@@ skipping 146 matching lines @@
     }
     if (!db_.Execute("CREATE INDEX logins_signon ON "
                      "logins (signon_realm)")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
-void LoginDatabase::ReportMetrics(const std::string& sync_username) {
+void LoginDatabase::ReportMetrics(const std::string& sync_username,
+                                  bool custom_passphrase_sync_enabled) {
   sql::Statement s(db_.GetCachedStatement(
       SQL_FROM_HERE,
       "SELECT signon_realm, blacklisted_by_user, COUNT(username_value) "
       "FROM logins GROUP BY signon_realm, blacklisted_by_user"));
 
   if (!s.is_valid())
     return;
 
+  std::string custom_passphrase = "WithoutCustomPassphrase";
+  if (custom_passphrase_sync_enabled) {
+    custom_passphrase = "WithCustomPassphrase";
+  }
+
   int total_accounts = 0;
   int blacklisted_sites = 0;
   while (s.Step()) {
     int blacklisted = s.ColumnInt(1);
     int accounts_per_site = s.ColumnInt(2);
     if (blacklisted) {
       ++blacklisted_sites;
     } else {
       total_accounts += accounts_per_site;
-      UMA_HISTOGRAM_CUSTOM_COUNTS("PasswordManager.AccountsPerSite",
-                                  accounts_per_site, 0, 32, 6);
+      LogAccountStat(base::StringPrintf("PasswordManager.AccountsPerSite.%s",
+                                        custom_passphrase.c_str()),
+                     accounts_per_site);
     }
   }
-  UMA_HISTOGRAM_CUSTOM_COUNTS("PasswordManager.TotalAccounts",
-                              total_accounts, 0, 32, 6);
-  UMA_HISTOGRAM_CUSTOM_COUNTS("PasswordManager.BlacklistedSites",
-                              blacklisted_sites, 0, 32, 6);
+  LogAccountStat(base::StringPrintf("PasswordManager.TotalAccounts.%s",
+                                    custom_passphrase.c_str()),
+                 total_accounts);
+  LogAccountStat(base::StringPrintf("PasswordManager.BlacklistedSites.%s",
+                                    custom_passphrase.c_str()),
+                 blacklisted_sites);
 
   sql::Statement usage_statement(db_.GetCachedStatement(
       SQL_FROM_HERE,
       "SELECT password_type, times_used FROM logins"));
 
   if (!usage_statement.is_valid())
     return;
 
   while (usage_statement.Step()) {
     PasswordForm::Type type = static_cast<PasswordForm::Type>(
         usage_statement.ColumnInt(0));
 
     if (type == PasswordForm::TYPE_GENERATED) {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "PasswordManager.TimesGeneratedPasswordUsed",
-          usage_statement.ColumnInt(1), 0, 100, 10);
+      LogTimesUsedStat(
+          base::StringPrintf("PasswordManager.TimesGeneratedPasswordUsed.%s",
+                             custom_passphrase.c_str()),
+          usage_statement.ColumnInt(1));
     } else {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "PasswordManager.TimesPasswordUsed",
-          usage_statement.ColumnInt(1), 0, 100, 10);
+      LogTimesUsedStat(
+          base::StringPrintf("PasswordManager.TimesPasswordUsed.%s",
+                             custom_passphrase.c_str()),
+          usage_statement.ColumnInt(1));
     }
   }
 
   bool syncing_account_saved = false;
   if (!sync_username.empty()) {
     sql::Statement sync_statement(db_.GetCachedStatement(
         SQL_FROM_HERE,
         "SELECT username_value FROM logins "
         "WHERE signon_realm == ?"));
     sync_statement.BindString(
@@ skipping 424 matching lines @@
 
 bool LoginDatabase::DeleteAndRecreateDatabaseFile() {
   DCHECK(db_.is_open());
   meta_table_.Reset();
   db_.Close();
   sql::Connection::Delete(db_path_);
   return Init(db_path_);
 }
 
 }  // namespace password_manager