Log Autofill.Quality.*.ByFieldType by predicted type for unknown data.

components/autofill/core/browser/form_structure.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/form_structure.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 29 matching lines @@
 #include "components/rappor/rappor_service_impl.h"
 #include "components/ukm/public/ukm_recorder.h"
 
 namespace autofill {
 namespace {
 
 const char kClientVersion[] = "6.1.1715.1442/en (GGLL)";
 const char kBillingMode[] = "billing";
 const char kShippingMode[] = "shipping";
 
-// A form is considered to have a high prediction mismatch rate if the number of
-// mismatches exceeds this threshold.
-const int kNumberOfMismatchesThreshold = 3;
-
 // Only removing common name prefixes if we have a minimum number of fields and
 // a minimum prefix length. These values are chosen to avoid cases such as two
 // fields with "address1" and "address2" and be effective against web frameworks
 // which prepend prefixes such as "ctl01$ctl00$MainContentRegion$" on all
 // fields.
 const int kCommonNamePrefixRemovalFieldThreshold = 3;
 const int kMinCommonNamePrefixLength = 16;
 
 // Helper for |EncodeUploadRequest()| that creates a bit field corresponding to
 // |available_field_types| and returns the hex representation as a string.
@@ skipping 630 matching lines @@
 
 void FormStructure::LogQualityMetrics(
     const base::TimeTicks& load_time,
     const base::TimeTicks& interaction_time,
     const base::TimeTicks& submission_time,
     rappor::RapporServiceImpl* rappor_service,
     AutofillMetrics::FormInteractionsUkmLogger* form_interactions_ukm_logger,
     bool did_show_suggestions,
     bool observed_submission) const {
   size_t num_detected_field_types = 0;
-  size_t num_server_mismatches = 0;
-  size_t num_heuristic_mismatches = 0;
   size_t num_edited_autofilled_fields = 0;
   bool did_autofill_all_possible_fields = true;
   bool did_autofill_some_possible_fields = false;
 
   // Determine the correct suffix for the metric, depending on whether or
   // not a submission was observed.
   const AutofillMetrics::QualityMetricType metric_type =
       observed_submission ? AutofillMetrics::TYPE_SUBMISSION
                           : AutofillMetrics::TYPE_NO_SUBMISSION;
 
@@ skipping 18 matching lines @@
     // Aliases for the field types predicted by heuristics, server and overall.
     ServerFieldType heuristic_type =
         AutofillType(field->heuristic_type()).GetStorableType();
     ServerFieldType server_type =
         AutofillType(field->server_type()).GetStorableType();
     ServerFieldType predicted_type = field->Type().GetStorableType();
 
     const ServerFieldTypeSet& field_types = field->possible_types();
     DCHECK(!field_types.empty());
 
-    // If the field data is empty, or unrecognized, log whether or not autofill
-    // predicted that it would be populated with an autofillable data type.
-    bool has_empty_data = field_types.count(EMPTY_TYPE) != 0;
-    bool has_unrecognized_data = field_types.count(UNKNOWN_TYPE) != 0;
-    if (has_empty_data || has_unrecognized_data) {
-      AutofillMetrics::FieldTypeQualityMetric match_empty_or_unknown =
-          has_empty_data ? AutofillMetrics::TYPE_MATCH_EMPTY
-                         : AutofillMetrics::TYPE_MATCH_UNKNOWN;
-      AutofillMetrics::FieldTypeQualityMetric mismatch_empty_or_unknown =
-          has_empty_data ? AutofillMetrics::TYPE_MISMATCH_EMPTY
-                         : AutofillMetrics::TYPE_MISMATCH_UNKNOWN;
-      ServerFieldType field_type = has_empty_data ? EMPTY_TYPE : UNKNOWN_TYPE;
-      AutofillMetrics::LogHeuristicTypePrediction(
-          (heuristic_type == UNKNOWN_TYPE ? match_empty_or_unknown
-                                          : mismatch_empty_or_unknown),
-          field_type, metric_type);
-      AutofillMetrics::LogServerTypePrediction(
-          (server_type == NO_SERVER_DATA ? match_empty_or_unknown
-                                         : mismatch_empty_or_unknown),
-          field_type, metric_type);
-      AutofillMetrics::LogOverallTypePrediction(
-          (predicted_type == UNKNOWN_TYPE ? match_empty_or_unknown
-                                          : mismatch_empty_or_unknown),
-          field_type, metric_type);
+    AutofillMetrics::LogHeuristicPredictionQualityMetrics(
+        field_types, heuristic_type, metric_type);
+    AutofillMetrics::LogServerPredictionQualityMetrics(field_types, server_type,
+                                                       metric_type);
+    AutofillMetrics::LogOverallPredictionQualityMetrics(
+        field_types, predicted_type, metric_type);
+
+    if (field_types.count(EMPTY_TYPE) || field_types.count(UNKNOWN_TYPE))
       continue;
-    }
 
     ++num_detected_field_types;
     if (field->is_autofilled)
       did_autofill_some_possible_fields = true;
     else
       did_autofill_all_possible_fields = false;
-
-    // Collapse field types that Chrome treats as identical, e.g. home and
-    // billing address fields.
-    ServerFieldTypeSet collapsed_field_types;
-    for (const auto& it : field_types) {
-      // Since we currently only support US phone numbers, the (city code + main
-      // digits) number is almost always identical to the whole phone number.
-      // TODO(isherman): Improve this logic once we add support for
-      // international numbers.
-      if (it == PHONE_HOME_CITY_AND_NUMBER)
-        collapsed_field_types.insert(PHONE_HOME_WHOLE_NUMBER);
-      else
-        collapsed_field_types.insert(AutofillType(it).GetStorableType());
-    }
-
-    // Capture the field's type, if it is unambiguous.
-    ServerFieldType field_type = UNKNOWN_TYPE;
-    if (collapsed_field_types.size() == 1)
-      field_type = *collapsed_field_types.begin();
-
-    // Log heuristic, server, and overall type quality metrics.
-    if (heuristic_type == UNKNOWN_TYPE) {
-      AutofillMetrics::LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
-                                                  field_type, metric_type);
-    } else if (field_types.count(heuristic_type)) {
-      AutofillMetrics::LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH,
-                                                  field_type, metric_type);
-    } else {
-      ++num_heuristic_mismatches;
-      AutofillMetrics::LogHeuristicTypePrediction(
-          AutofillMetrics::TYPE_MISMATCH, field_type, metric_type);
-    }
-
-    if (server_type == NO_SERVER_DATA) {
-      AutofillMetrics::LogServerTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
-                                               field_type, metric_type);
-    } else if (field_types.count(server_type)) {
-      AutofillMetrics::LogServerTypePrediction(AutofillMetrics::TYPE_MATCH,
-                                               field_type, metric_type);
-    } else {
-      ++num_server_mismatches;
-      AutofillMetrics::LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH,
-                                               field_type, metric_type);
-    }
-
-    if (predicted_type == UNKNOWN_TYPE) {
-      AutofillMetrics::LogOverallTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
-                                                field_type, metric_type);
-    } else if (field_types.count(predicted_type)) {
-      AutofillMetrics::LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH,
-                                                field_type, metric_type);
-    } else {
-      AutofillMetrics::LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH,
-                                                field_type, metric_type);
-    }
   }
 
   AutofillMetrics::LogNumberOfEditedAutofilledFields(
       num_edited_autofilled_fields, observed_submission);
 
   // We log "submission" and duration metrics if we are here after observing a
   // submission event.
   if (observed_submission) {
     AutofillMetrics::AutofillFormSubmittedState state;
     if (num_detected_field_types < kRequiredFieldsForPredictionRoutines) {
       state = AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA;
     } else {
       if (did_autofill_all_possible_fields) {
         state = AutofillMetrics::FILLABLE_FORM_AUTOFILLED_ALL;
       } else if (did_autofill_some_possible_fields) {
         state = AutofillMetrics::FILLABLE_FORM_AUTOFILLED_SOME;
       } else if (!did_show_suggestions) {
         state = AutofillMetrics::
             FILLABLE_FORM_AUTOFILLED_NONE_DID_NOT_SHOW_SUGGESTIONS;
       } else {
         state =
             AutofillMetrics::FILLABLE_FORM_AUTOFILLED_NONE_DID_SHOW_SUGGESTIONS;
       }
 
-      // Log some RAPPOR metrics for problematic cases.
-      if (num_server_mismatches >= kNumberOfMismatchesThreshold) {
-        rappor::SampleDomainAndRegistryFromGURL(
-            rappor_service, "Autofill.HighNumberOfServerMismatches",
-            source_url_);
-      }
-      if (num_heuristic_mismatches >= kNumberOfMismatchesThreshold) {
-        rappor::SampleDomainAndRegistryFromGURL(
-            rappor_service, "Autofill.HighNumberOfHeuristicMismatches",
-            source_url_);
-      }
-
       // Unlike the other times, the |submission_time| should always be
       // available.
       DCHECK(!submission_time.is_null());
 
       // The |load_time| might be unset, in the case that the form was
       // dynamically
       // added to the DOM.
       if (!load_time.is_null()) {
         // Submission should always chronologically follow form load.
         DCHECK(submission_time > load_time);
@@ skipping 20 matching lines @@
       }
     }
     if (form_interactions_ukm_logger->url() != source_url())
       form_interactions_ukm_logger->UpdateSourceURL(source_url());
     AutofillMetrics::LogAutofillFormSubmittedState(
         state, form_interactions_ukm_logger);
   }
 }
 
 void FormStructure::LogQualityMetricsBasedOnAutocomplete() const {
+  const AutofillMetrics::QualityMetricType metric_type =
+      AutofillMetrics::TYPE_AUTOCOMPLETE_BASED;
   for (const auto& field : fields_) {
     if (field->html_type() != HTML_TYPE_UNSPECIFIED &&
         field->html_type() != HTML_TYPE_UNRECOGNIZED) {
       // The type inferred by the autocomplete attribute.
-      AutofillType type(field->html_type(), field->html_mode());
-      ServerFieldType actual_field_type = type.GetStorableType();
+      ServerFieldTypeSet actual_field_type_set{
+          AutofillType(field->html_type(), field->html_mode())
+              .GetStorableType()};
 
-      const AutofillMetrics::QualityMetricType metric_type =
-          AutofillMetrics::TYPE_AUTOCOMPLETE_BASED;
-      // Log the quality of our heuristics predictions.
-      if (field->heuristic_type() == UNKNOWN_TYPE) {
-        AutofillMetrics::LogHeuristicTypePrediction(
-            AutofillMetrics::TYPE_UNKNOWN, actual_field_type, metric_type);
-      } else if (field->heuristic_type() == actual_field_type) {
-        AutofillMetrics::LogHeuristicTypePrediction(
-            AutofillMetrics::TYPE_MATCH, actual_field_type, metric_type);
-      } else {
-        AutofillMetrics::LogHeuristicTypePrediction(
-            AutofillMetrics::TYPE_MISMATCH, actual_field_type, metric_type);
-      }
-
-      // Log the quality of our server predictions.
-      if (field->server_type() == NO_SERVER_DATA) {
-        AutofillMetrics::LogServerTypePrediction(
-            AutofillMetrics::TYPE_UNKNOWN, actual_field_type, metric_type);
-      } else if (field->server_type() == actual_field_type) {
-        AutofillMetrics::LogServerTypePrediction(
-            AutofillMetrics::TYPE_MATCH, actual_field_type, metric_type);
-      } else {
-        AutofillMetrics::LogServerTypePrediction(
-            AutofillMetrics::TYPE_MISMATCH, actual_field_type, metric_type);
-      }
+      AutofillMetrics::LogHeuristicPredictionQualityMetrics(
+          actual_field_type_set, field->heuristic_type(), metric_type);
+      AutofillMetrics::LogServerPredictionQualityMetrics(
+          actual_field_type_set, field->server_type(), metric_type);
     }
   }
 }
 
 void FormStructure::ParseFieldTypesFromAutocompleteAttributes() {
   const std::string kDefaultSection = "-default";
 
   has_author_specified_types_ = false;
   has_author_specified_sections_ = false;
   has_author_specified_upi_vpa_hint_ = false;
@@ skipping 434 matching lines @@
               filtered_strings[0].at(prefix_len)) {
         // Mismatch found.
         return filtered_strings[i].substr(0, prefix_len);
       }
     }
   }
   return filtered_strings[0];
 }
 
 }  // namespace autofill