Measure how often PSL and same-organization name credentials are suppressed.

components/password_manager/core/browser/password_form_manager.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/password_manager/core/browser/password_form_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 246 matching lines @@
                             kMaxNumActionsTaken);
 
   // Use the visible main frame URL at the time the PasswordFormManager
   // is created, in case a navigation has already started and the
   // visible URL has changed.
   if (!is_main_frame_secure_) {
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.ActionsTakenOnNonSecureForm",
                               GetActionsTaken(), kMaxNumActionsTaken);
   }
 
-  if (!observed_form_.origin.SchemeIsCryptographic()) {
-    UMA_HISTOGRAM_BOOLEAN(
-        "PasswordManager.QueryingSuppressedAccountsFinished",
-        form_fetcher_->DidCompleteQueryingSuppressedHTTPSForms());
-    if (form_fetcher_->DidCompleteQueryingSuppressedHTTPSForms()) {
-      UMA_HISTOGRAM_ENUMERATION(
-          "PasswordManager.SuppressedAccount.Generated.HTTPSNotHTTP",
-          GetStatsForSuppressedHTTPSAccount(PasswordForm::TYPE_GENERATED),
-          kMaxSuppressedAccountStats);
-      UMA_HISTOGRAM_ENUMERATION(
-          "PasswordManager.SuppressedAccount.Manual.HTTPSNotHTTP",
-          GetStatsForSuppressedHTTPSAccount(PasswordForm::TYPE_MANUAL),
-          kMaxSuppressedAccountStats);
-    }
-  }
+  RecordHistogramsOnSuppressedAccounts();
 
   if (submit_result_ == kSubmitResultNotSubmitted) {
     if (has_generated_password_)
       metrics_util::LogPasswordGenerationSubmissionEvent(
           metrics_util::PASSWORD_NOT_SUBMITTED);
     else if (generation_available_)
       metrics_util::LogPasswordGenerationAvailableSubmissionEvent(
           metrics_util::PASSWORD_NOT_SUBMITTED);
   }
 
   if (form_type_ != kFormTypeUnspecified) {
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.SubmittedFormType", form_type_,
                               kFormTypeMax);
     if (!is_main_frame_secure_) {
       UMA_HISTOGRAM_ENUMERATION("PasswordManager.SubmittedNonSecureFormType",
                                 form_type_, kFormTypeMax);
     }
   }
 }
 
 int PasswordFormManager::GetActionsTaken() const {
   return user_action_ +
          kUserActionMax *
              (manager_action_ + kManagerActionMax * submit_result_);
 }
 
-int PasswordFormManager::GetStatsForSuppressedHTTPSAccount(
-    PasswordForm::Type type) const {
-  DCHECK(form_fetcher_->DidCompleteQueryingSuppressedHTTPSForms());
+int PasswordFormManager::GetHistogramSampleForSuppressedAccounts(
+    const std::vector<const autofill::PasswordForm*> suppressed_forms,
+    PasswordForm::Type manual_or_generated) const {
+  DCHECK(form_fetcher_->DidCompleteQueryingSuppressedForms());
 
   SuppressedAccountExistence best_matching_account = kSuppressedAccountNone;
-  for (const autofill::PasswordForm* form :
-       form_fetcher_->GetSuppressedHTTPSForms()) {
-    if (form->type != type)
+  for (const autofill::PasswordForm* form : suppressed_forms) {
+    if (form->type != manual_or_generated)
       continue;
 
     SuppressedAccountExistence current_account;
     if (pending_credentials_.password_value.empty())
       current_account = kSuppressedAccountExists;
     else if (form->username_value != pending_credentials_.username_value)
       current_account = kSuppressedAccountExistsDifferentUsername;
     else if (form->password_value != pending_credentials_.password_value)
       current_account = kSuppressedAccountExistsSameUsername;
     else
@@ skipping 12 matching lines @@
   // Encoding: most significant digit is the |best_matching_account|.
   int mixed_base_encoding = 0;
   mixed_base_encoding += best_matching_account;
   (mixed_base_encoding *= kSubmitResultMax) += submit_result_;
   (mixed_base_encoding *= kManagerActionNewMax) += manager_action_new;
   (mixed_base_encoding *= kUserActionMax) += user_action_;
   DCHECK_LT(mixed_base_encoding, kMaxSuppressedAccountStats);
   return mixed_base_encoding;
 }
 
+void PasswordFormManager::RecordHistogramsOnSuppressedAccounts() const {
+  UMA_HISTOGRAM_BOOLEAN("PasswordManager.QueryingSuppressedAccountsFinished",
+                        form_fetcher_->DidCompleteQueryingSuppressedForms());
+
+  if (!form_fetcher_->DidCompleteQueryingSuppressedForms())
+    return;
+
+  if (!observed_form_.origin.SchemeIsCryptographic()) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "PasswordManager.SuppressedAccount.Generated.HTTPSNotHTTP",
+        GetHistogramSampleForSuppressedAccounts(
+            form_fetcher_->GetSuppressedHTTPSForms(),
+            PasswordForm::TYPE_GENERATED),
+        kMaxSuppressedAccountStats);
+    UMA_HISTOGRAM_ENUMERATION(
+        "PasswordManager.SuppressedAccount.Manual.HTTPSNotHTTP",
+        GetHistogramSampleForSuppressedAccounts(
+            form_fetcher_->GetSuppressedHTTPSForms(),
+            PasswordForm::TYPE_MANUAL),
+        kMaxSuppressedAccountStats);
+  }
+
+  UMA_HISTOGRAM_ENUMERATION(
+      "PasswordManager.SuppressedAccount.Generated.PSLMatching",

[dvadym, 2017/05/30 14:17:00]

What're the other reasons except http vs https when PSL matches are suppressed?

[engedy, 2017/05/30 14:21:25]

That's a bit tricky. In these histograms, PSL matches are always considered
`suppressed`, and they have to be the same scheme.

+      GetHistogramSampleForSuppressedAccounts(
+          form_fetcher_->GetSuppressedPSLMatchingForms(),
+          PasswordForm::TYPE_GENERATED),
+      kMaxSuppressedAccountStats);
+  UMA_HISTOGRAM_ENUMERATION(
+      "PasswordManager.SuppressedAccount.Manual.PSLMatching",
+      GetHistogramSampleForSuppressedAccounts(
+          form_fetcher_->GetSuppressedPSLMatchingForms(),
+          PasswordForm::TYPE_MANUAL),
+      kMaxSuppressedAccountStats);
+
+  UMA_HISTOGRAM_ENUMERATION(
+      "PasswordManager.SuppressedAccount.Generated.SameOrganizationName",
+      GetHistogramSampleForSuppressedAccounts(
+          form_fetcher_->GetSuppressedSameOrganizationNameForms(),
+          PasswordForm::TYPE_GENERATED),
+      kMaxSuppressedAccountStats);
+  UMA_HISTOGRAM_ENUMERATION(
+      "PasswordManager.SuppressedAccount.Manual.SameOrganizationName",
+      GetHistogramSampleForSuppressedAccounts(
+          form_fetcher_->GetSuppressedSameOrganizationNameForms(),
+          PasswordForm::TYPE_MANUAL),
+      kMaxSuppressedAccountStats);
+}
+
 // static
 base::string16 PasswordFormManager::PasswordToSave(const PasswordForm& form) {
   if (form.new_password_element.empty() || form.new_password_value.empty())
     return form.password_value;
   return form.new_password_value;
 }
 
 // TODO(crbug.com/700420): Refactor this function, to make comparison more
 // reliable.
 PasswordFormManager::MatchResultMask PasswordFormManager::DoesManage(
@@ skipping 1107 matching lines @@
         credentials_to_update->back().password_value =
             pending_credentials_.password_value;
       }
     }
   }
 
   return old_primary_key;
 }
 
 }  // namespace password_manager