[autofill] Expand Autofill.Quality.* to log false positives/true negatives.

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 675 matching lines @@
                                       const base::TimeTicks& submission_time,
                                       rappor::RapporServiceImpl* rappor_service,
                                       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;
+
   for (size_t i = 0; i < field_count(); ++i) {
     auto* const field = this->field(i);
 
     // No further logging for password fields.  Those are primarily related to a
     // different feature code path, and so make more sense to track outside of
     // this metric.
     if (field->form_control_type == "password")
       continue;
 
     // We count fields that were autofilled but later modified, regardless of
     // whether the data now in the field is recognized.
     if (field->previously_autofilled())
       num_edited_autofilled_fields++;
 
-    // No further logging for empty fields nor for fields where the entered data
-    // does not appear to already exist in the user's stored Autofill data.
+    // 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 (field_types.count(EMPTY_TYPE) || field_types.count(UNKNOWN_TYPE))
+
+    // 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);
       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();
 
-    ServerFieldType heuristic_type =
-        AutofillType(field->heuristic_type()).GetStorableType();
-    ServerFieldType server_type =
-        AutofillType(field->server_type()).GetStorableType();
-    ServerFieldType predicted_type = field->Type().GetStorableType();
-
-    // Log heuristic, server, and overall type quality metrics, independently of
-    // whether the field was autofilled.
-    const AutofillMetrics::QualityMetricType metric_type =
-        observed_submission ? AutofillMetrics::TYPE_SUBMISSION
-                            : AutofillMetrics::TYPE_NO_SUBMISSION;
+    // 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);
@@ skipping 576 matching lines @@
               filtered_strings[0].at(prefix_len)) {
         // Mismatch found.
         return filtered_strings[i].substr(0, prefix_len);
       }
     }
   }
   return filtered_strings[0];
 }
 
 }  // namespace autofill