Uses fine grained histogram buckets for CVC errors.

components/autofill/core/browser/autofill_manager.cc

 // Copyright 2013 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/autofill/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 227 matching lines @@
               true /* is_for_credit_card */,
               form_interactions_ukm_logger_.get())),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       user_did_accept_upload_prompt_(false),
       should_cvc_be_requested_(false),
+      found_cvc_field_(false),
+      found_cvc_value_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
 #if defined(OS_ANDROID) || defined(OS_IOS)
       autofill_assistant_(this),
 #endif
       weak_ptr_factory_(this) {
   if (enable_download_manager == ENABLE_AUTOFILL_DOWNLOAD_MANAGER) {
     download_manager_.reset(new AutofillDownloadManager(driver, this));
   }
   CountryNames::SetLocaleString(app_locale_);
@@ skipping 790 matching lines @@
     // credentials until the user has explicitly accepted a prompt to upload.
     upload_request_.context_token = context_token;
     user_did_accept_upload_prompt_ = false;
     client_->ConfirmSaveCreditCardToCloud(
         upload_request_.card, std::move(legal_message),
         should_cvc_be_requested_,
         base::Bind(&AutofillManager::OnUserDidAcceptUpload,
                    weak_ptr_factory_.GetWeakPtr()));
     client_->LoadRiskData(base::Bind(&AutofillManager::OnDidGetUploadRiskData,
                                      weak_ptr_factory_.GetWeakPtr()));
-    card_upload_decision_metrics = should_cvc_be_requested_
-                                       ? AutofillMetrics::UPLOAD_OFFERED_NO_CVC
-                                       : AutofillMetrics::UPLOAD_OFFERED;
+    card_upload_decision_metrics = AutofillMetrics::UPLOAD_OFFERED;
+    if (!found_cvc_field_ || !found_cvc_value_)
+      DCHECK(should_cvc_be_requested_);
+    if (found_cvc_field_) {
+      if (found_cvc_value_) {
+        if (should_cvc_be_requested_)
+          card_upload_decision_metrics |= AutofillMetrics::INVALID_CVC_VALUE;
+      } else {
+        card_upload_decision_metrics |= AutofillMetrics::CVC_VALUE_NOT_FOUND;
+      }
+    } else {
+      card_upload_decision_metrics |= AutofillMetrics::CVC_FIELD_NOT_FOUND;
+    }
   } else {
     // If the upload details request failed, fall back to a local save. The
     // reasoning here is as follows:
     // - This will sometimes fail intermittently, in which case it might be
     // better to not fall back, because sometimes offering upload and sometimes
     // offering local save is a poor user experience.
     // - However, in some cases, our local configuration limiting the feature to
     // countries that Payments is known to support will not match Payments' own
     // determination of what country the user is located in. In these cases,
     // the upload details request will consistently fail and if we don't fall
@@ skipping 170 matching lines @@
     //     validation rules
     // Here we perform both checks before returning or logging anything,
     // because if only one of the two is missing, it may be fixable.
 
     // Check for a CVC to determine whether we can prompt the user to upload
     // their card. If no CVC is present and the experiment is off, do nothing.
     // We could fall back to a local save but we believe that sometimes offering
     // upload and sometimes offering local save is a confusing user experience.
     // If no CVC and the experiment is on, request CVC from the user in the
     // bubble and save using the provided value.
+    found_cvc_field_ = false;
+    found_cvc_value_ = false;
     for (const auto& field : submitted_form) {
-      if (field->Type().GetStorableType() == CREDIT_CARD_VERIFICATION_CODE &&
-          IsValidCreditCardSecurityCode(field->value,
-                                        upload_request_.card.network())) {
-        upload_request_.cvc = field->value;
-        break;
+      if (field->Type().GetStorableType() == CREDIT_CARD_VERIFICATION_CODE) {
+        found_cvc_field_ = true;
+        if (!field->value.empty())
+          found_cvc_value_ = true;
+        if (IsValidCreditCardSecurityCode(field->value,
+                                          upload_request_.card.network())) {
+          upload_request_.cvc = field->value;
+          break;
+        }
       }
     }
 
     // Upload requires that recently used or modified addresses meet the
     // client-side validation rules.
     std::string rappor_metric_name;
     int upload_decision_metrics = GetProfilesForCreditCardUpload(
         *imported_credit_card, &upload_request_.profiles, &rappor_metric_name);
 
     pending_upload_request_url_ = GURL(submitted_form.source_url());
 
     // Both the CVC and address checks are done.  Conform to the legacy order of
     // reporting on CVC then address.
     should_cvc_be_requested_ = false;
     if (upload_request_.cvc.empty()) {
       should_cvc_be_requested_ =
           (!upload_decision_metrics &&
            IsAutofillUpstreamRequestCvcIfMissingExperimentEnabled());
       if (!should_cvc_be_requested_) {
-        upload_decision_metrics |= AutofillMetrics::UPLOAD_NOT_OFFERED_NO_CVC;
+        if (found_cvc_field_)
+          upload_decision_metrics |= found_cvc_value_
+                                         ? AutofillMetrics::INVALID_CVC_VALUE
+                                         : AutofillMetrics::CVC_VALUE_NOT_FOUND;
+        else
+          upload_decision_metrics |= AutofillMetrics::CVC_FIELD_NOT_FOUND;
         rappor_metric_name = "Autofill.CardUploadNotOfferedNoCvc";
       }
     }
     if (upload_decision_metrics) {
       LogCardUploadDecisions(upload_decision_metrics);
       pending_upload_request_url_ = GURL();
       if (!rappor_metric_name.empty()) {
         CollectRapporSample(submitted_form.source_url(), rappor_metric_name);
       }
       return;
@@ skipping 961 matching lines @@
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 void AutofillManager::LogCardUploadDecisions(int upload_decision_metrics) {
   AutofillMetrics::LogCardUploadDecisionMetrics(upload_decision_metrics);
   AutofillMetrics::LogCardUploadDecisionsUkm(client_->GetUkmService(),
                                              pending_upload_request_url_,
                                              upload_decision_metrics);
 }
 
 }  // namespace autofill