[Autofill] Quality metric based on autocomplete attributes.

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 482 matching lines @@
 
       // In some cases *successful* response does not return all the fields.
       // Quit the update of the types then.
       if (current_field == response.field().end())
         break;
 
       ServerFieldType field_type =
           static_cast<ServerFieldType>(current_field->autofill_type());
       query_response_has_no_server_data &= field_type == NO_SERVER_DATA;
 
-      // If |form->has_author_specified_types| only password fields should be
-      // updated.
-      if (!form->has_author_specified_types_ ||
-          field->form_control_type == "password") {
-        // UNKNOWN_TYPE is reserved for use by the client.
-        DCHECK_NE(field_type, UNKNOWN_TYPE);
+      // UNKNOWN_TYPE is reserved for use by the client.
+      DCHECK_NE(field_type, UNKNOWN_TYPE);
 
-        ServerFieldType heuristic_type = field->heuristic_type();
-        if (heuristic_type != UNKNOWN_TYPE)
-          heuristics_detected_fillable_field = true;
+      ServerFieldType heuristic_type = field->heuristic_type();
+      if (heuristic_type != UNKNOWN_TYPE)
+        heuristics_detected_fillable_field = true;
 
-        field->set_server_type(field_type);
-        if (heuristic_type != field->Type().GetStorableType())
-          query_response_overrode_heuristics = true;
-      }
+      field->set_server_type(field_type);
+      if (heuristic_type != field->Type().GetStorableType())
+        query_response_overrode_heuristics = true;
 
       ++current_field;
     }
 
     AutofillMetrics::LogServerResponseHasDataForForm(
         !query_response_has_no_server_data);
     if (query_response_has_no_server_data && form->source_url().is_valid()) {
       rappor::SampleDomainAndRegistryFromGURL(
           rappor_service, "Autofill.QueryResponseHasNoServerDataForForm",
           form->source_url());
@@ skipping 199 matching lines @@
       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;
     if (heuristic_type == UNKNOWN_TYPE) {
-      AutofillMetrics::LogHeuristicTypePrediction(
-          AutofillMetrics::TYPE_UNKNOWN, field_type, observed_submission);
+      AutofillMetrics::LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
+                                                  field_type, metric_type);
     } else if (field_types.count(heuristic_type)) {
-      AutofillMetrics::LogHeuristicTypePrediction(
-          AutofillMetrics::TYPE_MATCH, field_type, observed_submission);
+      AutofillMetrics::LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH,
+                                                  field_type, metric_type);
     } else {
       ++num_heuristic_mismatches;
       AutofillMetrics::LogHeuristicTypePrediction(
-          AutofillMetrics::TYPE_MISMATCH, field_type, observed_submission);
+          AutofillMetrics::TYPE_MISMATCH, field_type, metric_type);
     }
 
     if (server_type == NO_SERVER_DATA) {
       AutofillMetrics::LogServerTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
-                                               field_type, observed_submission);
+                                               field_type, metric_type);
     } else if (field_types.count(server_type)) {
       AutofillMetrics::LogServerTypePrediction(AutofillMetrics::TYPE_MATCH,
-                                               field_type, observed_submission);
+                                               field_type, metric_type);
     } else {
       ++num_server_mismatches;
       AutofillMetrics::LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH,
-                                               field_type, observed_submission);
+                                               field_type, metric_type);
     }
 
     if (predicted_type == UNKNOWN_TYPE) {
-      AutofillMetrics::LogOverallTypePrediction(
-          AutofillMetrics::TYPE_UNKNOWN, field_type, observed_submission);
+      AutofillMetrics::LogOverallTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
+                                                field_type, metric_type);
     } else if (field_types.count(predicted_type)) {
-      AutofillMetrics::LogOverallTypePrediction(
-          AutofillMetrics::TYPE_MATCH, field_type, observed_submission);
+      AutofillMetrics::LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH,
+                                                field_type, metric_type);
     } else {
-      AutofillMetrics::LogOverallTypePrediction(
-          AutofillMetrics::TYPE_MISMATCH, field_type, observed_submission);
+      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) {
     if (num_detected_field_types < kRequiredFieldsForPredictionRoutines) {
@@ skipping 56 matching lines @@
               elapsed);
         } else {
           AutofillMetrics::LogFormFillDurationFromInteractionWithoutAutofill(
               elapsed);
         }
       }
     }
   }
 }
 
+void FormStructure::LogQualityMetricsBasedOnAutocomplete() const {
+  for (const AutofillField* 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();
+
+      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);
+      }
+    }
+  }
+}
+
 void FormStructure::ParseFieldTypesFromAutocompleteAttributes() {
   const std::string kDefaultSection = "-default";
 
   has_author_specified_types_ = false;
   has_author_specified_sections_ = false;
   for (AutofillField* field : fields_) {
     // To prevent potential section name collisions, add a default suffix for
     // other fields.  Without this, 'autocomplete' attribute values
     // "section--shipping street-address" and "shipping street-address" would be
     // parsed identically, given the section handling code below.  We do this
@@ skipping 474 matching lines @@
               filtered_strings[0].at(prefix_len)) {
         // Mismatch found.
         return filtered_strings[i].substr(0, prefix_len);
       }
     }
   }
   return filtered_strings[0];
 }
 
 }  // namespace autofill