[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 82 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);
+}
+
 }  // namespace
 
 LoginDatabase::LoginDatabase() {
 }
 
 LoginDatabase::~LoginDatabase() {
 }
 
 bool LoginDatabase::Init(const base::FilePath& db_path) {
   // Set pragmas for a small, private database (based on WebDatabase).
@@ skipping 140 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(PasswordManagerClient* client) {
   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;

[vabr (Chromium), 2014/10/13 09:24:18]

Should we have a non-empty value describing the situation without custom
passphrase value, to avoid mixing the old and the new semantics of the involved
histograms? What I mean: before, AccountsPerSite was reported for all users, now
it will only be reported for users without custom passphrase.

[Garrett Casto, 2014/10/13 20:57:56]

Yeah, seems reasonable. I was assuming that there would be a small enough
percentage of these users that it wouldn't appreciably affect the other stats,
but might as well be specific.

+  if (client->IsPasswordSyncEnabled(ONLY_CUSTOM_PASSPHRASE_USERS)) {
+    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);
+      LogDynamicUMAStat(base::StringPrintf("PasswordManager.AccountsPerSite%s",
+                                           custom_passphrase.c_str()),
+                        accounts_per_site,
+                        0,
+                        32,
+                        6);
     }
   }
-  UMA_HISTOGRAM_CUSTOM_COUNTS("PasswordManager.TotalAccounts",
-                              total_accounts, 0, 32, 6);
-  UMA_HISTOGRAM_CUSTOM_COUNTS("PasswordManager.BlacklistedSites",
-                              blacklisted_sites, 0, 32, 6);
+  LogDynamicUMAStat(base::StringPrintf("PasswordManager.TotalAccounts%s",
+                                       custom_passphrase.c_str()),
+                    total_accounts,
+                    0,
+                    32,
+                    6);
+  LogDynamicUMAStat(base::StringPrintf("PasswordManager.BlacklistedSites%s",
+                                       custom_passphrase.c_str()),
+                    blacklisted_sites,
+                    0,
+                    32,
+                    6);
 
   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);
+      LogDynamicUMAStat(
+          base::StringPrintf("PasswordManager.TimesGeneratedPasswordUsed%s",
+                             custom_passphrase.c_str()),
+          usage_statement.ColumnInt(1),
+          0,
+          100,
+          10);
     } else {
-      UMA_HISTOGRAM_CUSTOM_COUNTS(
-          "PasswordManager.TimesPasswordUsed",
-          usage_statement.ColumnInt(1), 0, 100, 10);
+      LogDynamicUMAStat(
+          base::StringPrintf("PasswordManager.TimesPasswordUsed%s",
+                             custom_passphrase.c_str()),
+          usage_statement.ColumnInt(1),
+          0,
+          100,
+          10);
     }
   }
 
   bool syncing_account_saved = false;
+  std::string sync_username = client->GetSyncUsername();
   if (!sync_username.empty()) {
     sql::Statement sync_statement(db_.GetCachedStatement(
         SQL_FROM_HERE,
         "SELECT username_value FROM logins "
         "WHERE signon_realm == ?"));
     sync_statement.BindString(
         0, GaiaUrls::GetInstance()->gaia_url().GetOrigin().spec());
 
     if (!sync_statement.is_valid())
       return;
@@ skipping 422 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