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

components/autofill/core/browser/autofill_metrics_unittest.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_metrics.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 505 matching lines @@
   // Simulate having seen this form on page load.
   autofill_manager_->AddSeenForm(form, heuristic_types, server_types);
 
   // Simulate form submission.
   base::HistogramTester histogram_tester;
   autofill_manager_->SubmitForm(form, TimeTicks::Now());
 
   // Heuristic predictions.
   // Unknown:
   histogram_tester.ExpectBucketCount("Autofill.Quality.HeuristicType",
-                                     AutofillMetrics::TYPE_UNKNOWN, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_UNKNOWN,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType",
       GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount("Autofill.Quality.HeuristicType",
-                                     AutofillMetrics::TYPE_MATCH, 2);
-  histogram_tester.ExpectBucketCount(
-      "Autofill.Quality.HeuristicType.ByFieldType",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MATCH), 1);
+                                     AutofillMetrics::TRUE_POSITIVE, 2);
+  histogram_tester.ExpectBucketCount(
+      "Autofill.Quality.HeuristicType.ByFieldType",
+      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TRUE_POSITIVE), 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType",
       GetFieldTypeGroupMetric(PHONE_HOME_CITY_AND_NUMBER,
-                              AutofillMetrics::TYPE_MATCH),
+                              AutofillMetrics::TRUE_POSITIVE),
       1);
   // Mismatch:
   histogram_tester.ExpectBucketCount("Autofill.Quality.HeuristicType",
-                                     AutofillMetrics::TYPE_MISMATCH, 1);
-  histogram_tester.ExpectBucketCount(
-      "Autofill.Quality.HeuristicType.ByFieldType",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MISMATCH),
+                                     AutofillMetrics::FALSE_NEGATIVE_MISMATCH,
+                                     1);
+  histogram_tester.ExpectBucketCount(
+      "Autofill.Quality.HeuristicType.ByFieldType",
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
       1);
 
   // Server predictions:
   // Unknown:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType",
-                                     AutofillMetrics::TYPE_UNKNOWN, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_UNKNOWN,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType",
       GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType",
-                                     AutofillMetrics::TYPE_MATCH, 2);
-  histogram_tester.ExpectBucketCount(
-      "Autofill.Quality.ServerType.ByFieldType",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MATCH), 1);
+                                     AutofillMetrics::TRUE_POSITIVE, 2);
+  histogram_tester.ExpectBucketCount(
+      "Autofill.Quality.ServerType.ByFieldType",
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TRUE_POSITIVE),
+      1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType",
       GetFieldTypeGroupMetric(PHONE_HOME_WHOLE_NUMBER,
-                              AutofillMetrics::TYPE_MATCH),
+                              AutofillMetrics::TRUE_POSITIVE),
       1);
   // Mismatch:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType",
-                                     AutofillMetrics::TYPE_MISMATCH, 1);
-  histogram_tester.ExpectBucketCount(
-      "Autofill.Quality.ServerType.ByFieldType",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MISMATCH), 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_MISMATCH,
+                                     1);
+  histogram_tester.ExpectBucketCount(
+      "Autofill.Quality.ServerType.ByFieldType",
+      GetFieldTypeGroupMetric(NAME_FULL,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
+      1);
 
   // Overall predictions:
   // Unknown:
   histogram_tester.ExpectBucketCount("Autofill.Quality.PredictedType",
-                                     AutofillMetrics::TYPE_UNKNOWN, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_UNKNOWN,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType",
       GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount("Autofill.Quality.PredictedType",
-                                     AutofillMetrics::TYPE_MATCH, 2);
-  histogram_tester.ExpectBucketCount(
-      "Autofill.Quality.PredictedType.ByFieldType",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MATCH), 1);
+                                     AutofillMetrics::TRUE_POSITIVE, 2);
+  histogram_tester.ExpectBucketCount(
+      "Autofill.Quality.PredictedType.ByFieldType",
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TRUE_POSITIVE),
+      1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType",
       GetFieldTypeGroupMetric(PHONE_HOME_WHOLE_NUMBER,
-                              AutofillMetrics::TYPE_MATCH),
+                              AutofillMetrics::TRUE_POSITIVE),
       1);
   // Mismatch:
   histogram_tester.ExpectBucketCount("Autofill.Quality.PredictedType",
-                                     AutofillMetrics::TYPE_MISMATCH, 1);
-  histogram_tester.ExpectBucketCount(
-      "Autofill.Quality.PredictedType.ByFieldType",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MISMATCH), 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_MISMATCH,
+                                     1);
+  histogram_tester.ExpectBucketCount(
+      "Autofill.Quality.PredictedType.ByFieldType",
+      GetFieldTypeGroupMetric(NAME_FULL,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
+      1);
 }
 
 // Tests the true negatives (empty + no prediction and unknown + no prediction)
 // and false positives (empty + bad prediction and unknown + bad prediction)
 // are counted correctly.
 
-struct UnrecognizedOrEmptyFieldsCase {
+struct QualityMetricsTestCase {
+  const ServerFieldType predicted_field_type;
   const ServerFieldType actual_field_type;
-  const bool make_prediction;
-  const AutofillMetrics::FieldTypeQualityMetric metric_to_test;
 };
 
-class UnrecognizedOrEmptyFieldsTest
+class QualityMetricsTest
     : public AutofillMetricsTest,
-      public testing::WithParamInterface<UnrecognizedOrEmptyFieldsCase> {};
-
-TEST_P(UnrecognizedOrEmptyFieldsTest, QualityMetrics) {
+      public testing::WithParamInterface<QualityMetricsTestCase> {
+ public:
+  const char* ValueForType(ServerFieldType type) {
+    switch (type) {
+      case EMPTY_TYPE:
+        return "";
+      case UNKNOWN_TYPE:
+        return "unknown";
+      case COMPANY_NAME:
+        return "Decca";
+      case NAME_FIRST:
+        return "Elvis";
+      case NAME_MIDDLE:
+        return "Aaron";
+      case NAME_LAST:
+        return "Presley";
+      case NAME_FULL:
+        return "Elvis Aaron Presley";
+      case EMAIL_ADDRESS:
+        return "buddy@gmail.com";
+      case PHONE_HOME_NUMBER:
+      case PHONE_HOME_WHOLE_NUMBER:
+      case PHONE_HOME_CITY_AND_NUMBER:
+        return "2345678901";
+      case ADDRESS_HOME_STREET_ADDRESS:
+        return "123 Apple St.\nunit 6";
+      case ADDRESS_HOME_LINE1:
+        return "123 Apple St.";
+      case ADDRESS_HOME_LINE2:
+        return "unit 6";
+      case ADDRESS_HOME_CITY:
+        return "Lubbock";
+      case ADDRESS_HOME_STATE:
+        return "Texas";
+      case ADDRESS_HOME_ZIP:
+        return "79401";
+      case ADDRESS_HOME_COUNTRY:
+        return "US";
+      default:
+        NOTREACHED();  // Fall through
+        return "unexpected!";
+    }
+  }
+
+  bool IsExampleOf(AutofillMetrics::FieldTypeQualityMetric metric,
+                   ServerFieldType predicted_type,
+                   ServerFieldType actual_type) {
+    switch (metric) {
+      case AutofillMetrics::TRUE_POSITIVE:
+        return actual_type != UNKNOWN_TYPE && actual_type != EMPTY_TYPE &&
+               predicted_type == actual_type;
+
+      case AutofillMetrics::TRUE_NEGATIVE_UNKNOWN:
+        return actual_type == UNKNOWN_TYPE && predicted_type == UNKNOWN_TYPE;
+
+      case AutofillMetrics::TRUE_NEGATIVE_EMPTY:
+        return actual_type == EMPTY_TYPE && predicted_type == UNKNOWN_TYPE;
+
+      // False negative mismatch and false positive mismatch trigger on the same
+      // conditions:
+      //   - False positive prediction of predicted type
+      //   - False negative prediction of actual type
+      case AutofillMetrics::FALSE_POSITIVE_MISMATCH:
+      case AutofillMetrics::FALSE_NEGATIVE_MISMATCH:
+        return actual_type != UNKNOWN_TYPE && actual_type != EMPTY_TYPE &&
+               actual_type != predicted_type && predicted_type != UNKNOWN_TYPE;
+
+      case AutofillMetrics::FALSE_POSITIVE_UNKNOWN:
+        return actual_type == UNKNOWN_TYPE && predicted_type != UNKNOWN_TYPE;
+
+      case AutofillMetrics::FALSE_POSITIVE_EMPTY:
+        return actual_type == EMPTY_TYPE && predicted_type != UNKNOWN_TYPE;
+
+      case AutofillMetrics::FALSE_NEGATIVE_UNKNOWN:
+        return actual_type != EMPTY_TYPE && actual_type != UNKNOWN_TYPE &&
+               actual_type != predicted_type && predicted_type == UNKNOWN_TYPE;
+      default:
+        NOTREACHED();
+    }
+    return false;
+  }
+};
+
+TEST_P(QualityMetricsTest, Classification) {
   // Setup the test parameters.
   const ServerFieldType actual_field_type = GetParam().actual_field_type;
-  const ServerFieldType heuristic_type =
-      GetParam().make_prediction ? EMAIL_ADDRESS : UNKNOWN_TYPE;
-  const ServerFieldType server_type =
-      GetParam().make_prediction ? EMAIL_ADDRESS : NO_SERVER_DATA;
-  const AutofillMetrics::FieldTypeQualityMetric metric_to_test =
-      GetParam().metric_to_test;
+  const ServerFieldType predicted_type = GetParam().predicted_field_type;
+
+  VLOG(2) << "Test Case = Predicted: "
+          << AutofillType(predicted_type).ToString() << "; "
+          << "Actual: " << AutofillType(actual_field_type).ToString();
 
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
 
   std::vector<ServerFieldType> heuristic_types, server_types;
   AutofillField field;
 
   // Add a first name field, that is predicted correctly.
-  test::CreateTestFormField("first", "first", "Elvis", "text", &field);
-  field.set_possible_types({NAME_FIRST});
+  test::CreateTestFormField("first", "first", ValueForType(NAME_FIRST), "text",
+                            &field);
   form.fields.push_back(field);
   heuristic_types.push_back(NAME_FIRST);
   server_types.push_back(NAME_FIRST);
 
   // Add a last name field, that is predicted correctly.
-  test::CreateTestFormField("last", "last", "Presley", "test", &field);
-  field.set_possible_types({NAME_LAST});
+  test::CreateTestFormField("last", "last", ValueForType(NAME_LAST), "test",
+                            &field);
   form.fields.push_back(field);
   heuristic_types.push_back(NAME_LAST);
   server_types.push_back(NAME_LAST);
 
   // Add an empty or unknown field, that is predicted as per the test params.
   test::CreateTestFormField("Unknown", "Unknown",
-                            (actual_field_type == EMPTY_TYPE ? "" : "unknown"),
-                            "text", &field);
-  field.set_possible_types({actual_field_type});
+                            ValueForType(actual_field_type), "text", &field);
   form.fields.push_back(field);
-  heuristic_types.push_back(heuristic_type);
-  server_types.push_back(server_type);
+  heuristic_types.push_back(predicted_type);
+  server_types.push_back(predicted_type == UNKNOWN_TYPE ? NO_SERVER_DATA
+                                                        : predicted_type);
 
   // Simulate having seen this form on page load.
   autofill_manager_->AddSeenForm(form, heuristic_types, server_types);
 
   // Run the form submission code while tracking the histograms.
   base::HistogramTester histogram_tester;
   autofill_manager_->SubmitForm(form, TimeTicks::Now());
 
   // Validate the histogram counter values.
   for (int i = 0; i < AutofillMetrics::NUM_FIELD_TYPE_QUALITY_METRICS; ++i) {
     // The metric enum value we're currently examining.
     auto metric = static_cast<AutofillMetrics::FieldTypeQualityMetric>(i);
 
-    // For the overall metric counts...
-    // If the current metric is the metric we're testing, then we expect its
-    // count to be 1. Otherwise, the metric's count should be zero (0) except
-    // for the TYPE_MATCH metric which should be 2 (because of the matching
-    // first and last name fields)
-    int overall_expected_count =
-        (metric == metric_to_test)
-            ? 1
-            : ((metric == AutofillMetrics::TYPE_MATCH) ? 2 : 0);
+    // The type specific expected count is 1 if (predicted, actual) is an
+    // example
+    int basic_expected_count =
+        IsExampleOf(metric, predicted_type, actual_field_type) ? 1 : 0;
+
+    // We don't capture aggregate FALSE_POSITIVE_MISMATCH.
+    int aggregate_expected_count =
+        (metric == AutofillMetrics::TRUE_POSITIVE ? 2 : 0) +
+        (metric == AutofillMetrics::FALSE_POSITIVE_MISMATCH
+             ? 0
+             : basic_expected_count);
 
     histogram_tester.ExpectBucketCount("Autofill.Quality.HeuristicType", metric,
-                                       overall_expected_count);
+                                       aggregate_expected_count);
     histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType", metric,
-                                       overall_expected_count);
+                                       aggregate_expected_count);
     histogram_tester.ExpectBucketCount("Autofill.Quality.PredictedType", metric,
-                                       overall_expected_count);
+                                       aggregate_expected_count);
 
-    // For the ByFieldType metric counts...
-    // We only examine the counter for the field_type being tested. If the
-    // current metric is the metric we're testing, then we expect its
-    // count to be 1 otherwise it should be 0.
-    int field_type_expected_count = (metric == metric_to_test) ? 1 : 0;
+    int expected_count_for_actual_type =
+        (actual_field_type != UNKNOWN_TYPE && actual_field_type != EMPTY_TYPE &&
+         metric != AutofillMetrics::FALSE_POSITIVE_MISMATCH)
+            ? basic_expected_count
+            : 0;
+
+    // For the ByFieldType metric counts for actual_field_type...
+    histogram_tester.ExpectBucketCount(
+        "Autofill.Quality.HeuristicType.ByFieldType",
+        GetFieldTypeGroupMetric(actual_field_type, metric),
+        expected_count_for_actual_type);
+    histogram_tester.ExpectBucketCount(
+        "Autofill.Quality.ServerType.ByFieldType",
+        GetFieldTypeGroupMetric(actual_field_type, metric),
+        expected_count_for_actual_type);
+    histogram_tester.ExpectBucketCount(
+        "Autofill.Quality.PredictedType.ByFieldType",
+        GetFieldTypeGroupMetric(actual_field_type, metric),
+        expected_count_for_actual_type);
+
+    int expected_count_for_predicted_type =
+        (predicted_type != UNKNOWN_TYPE &&
+         metric != AutofillMetrics::FALSE_NEGATIVE_MISMATCH)
+            ? basic_expected_count
+            : 0;
 
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.HeuristicType.ByFieldType",
-        GetFieldTypeGroupMetric(actual_field_type, metric),
-        field_type_expected_count);
+        GetFieldTypeGroupMetric(predicted_type, metric),
+        expected_count_for_predicted_type);
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.ServerType.ByFieldType",
-        GetFieldTypeGroupMetric(actual_field_type, metric),
-        field_type_expected_count);
+        GetFieldTypeGroupMetric(predicted_type, metric),
+        expected_count_for_predicted_type);
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.PredictedType.ByFieldType",
-        GetFieldTypeGroupMetric(actual_field_type, metric),
-        field_type_expected_count);
+        GetFieldTypeGroupMetric(predicted_type, metric),
+        expected_count_for_predicted_type);
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     AutofillMetricsTest,
-    UnrecognizedOrEmptyFieldsTest,
-    testing::Values(
-        UnrecognizedOrEmptyFieldsCase{EMPTY_TYPE,
-                                      /* make_prediction = */ false,
-                                      AutofillMetrics::TYPE_MATCH_EMPTY},
-        UnrecognizedOrEmptyFieldsCase{UNKNOWN_TYPE,
-                                      /* make_prediction = */ false,
-                                      AutofillMetrics::TYPE_MATCH_UNKNOWN},
-        UnrecognizedOrEmptyFieldsCase{EMPTY_TYPE,
-                                      /* make_prediction = */ true,
-                                      AutofillMetrics::TYPE_MISMATCH_EMPTY},
-        UnrecognizedOrEmptyFieldsCase{UNKNOWN_TYPE,
-                                      /* make_prediction = */ true,
-                                      AutofillMetrics::TYPE_MISMATCH_UNKNOWN}));
+    QualityMetricsTest,
+    testing::Values(QualityMetricsTestCase{UNKNOWN_TYPE, EMPTY_TYPE},
+                    QualityMetricsTestCase{UNKNOWN_TYPE, UNKNOWN_TYPE},
+                    QualityMetricsTestCase{UNKNOWN_TYPE, EMAIL_ADDRESS},
+                    QualityMetricsTestCase{EMAIL_ADDRESS, EMPTY_TYPE},
+                    QualityMetricsTestCase{EMAIL_ADDRESS, UNKNOWN_TYPE},
+                    QualityMetricsTestCase{EMAIL_ADDRESS, EMAIL_ADDRESS},
+                    QualityMetricsTestCase{EMAIL_ADDRESS, COMPANY_NAME},
+                    QualityMetricsTestCase{COMPANY_NAME, EMAIL_ADDRESS}));
 
 // Ensures that metrics that measure timing some important Autofill functions
 // actually are recorded and retrieved.
 TEST_F(AutofillMetricsTest, TimingMetrics) {
   base::HistogramTester histogram_tester;
 
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
@@ skipping 88 matching lines @@
   base::HistogramTester histogram_tester;
 
   autofill_manager_->ResetRunLoop();
   autofill_manager_->Reset();
   autofill_manager_->RunRunLoop();
 
   // Heuristic predictions.
   // Unknown:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.NoSubmission",
-      AutofillMetrics::TYPE_UNKNOWN, 1);
+      AutofillMetrics::FALSE_NEGATIVE_UNKNOWN, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType.NoSubmission",
       GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.NoSubmission",
-      AutofillMetrics::TYPE_MATCH, 2);
+      AutofillMetrics::TRUE_POSITIVE, 2);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType.NoSubmission",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MATCH), 1);
+      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TRUE_POSITIVE), 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType.NoSubmission",
       GetFieldTypeGroupMetric(PHONE_HOME_WHOLE_NUMBER,
-                              AutofillMetrics::TYPE_MATCH),
+                              AutofillMetrics::TRUE_POSITIVE),
       1);
   // Mismatch:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.NoSubmission",
-      AutofillMetrics::TYPE_MISMATCH, 1);
+      AutofillMetrics::FALSE_NEGATIVE_MISMATCH, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType.NoSubmission",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MISMATCH),
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
       1);
 
   // Server predictions:
   // Unknown:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType.NoSubmission",
-                                     AutofillMetrics::TYPE_UNKNOWN, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_UNKNOWN,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType.NoSubmission",
       GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType.NoSubmission",
-                                     AutofillMetrics::TYPE_MATCH, 2);
+                                     AutofillMetrics::TRUE_POSITIVE, 2);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType.NoSubmission",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MATCH), 1);
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TRUE_POSITIVE),
+      1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType.NoSubmission",
       GetFieldTypeGroupMetric(PHONE_HOME_WHOLE_NUMBER,
-                              AutofillMetrics::TYPE_MATCH),
+                              AutofillMetrics::TRUE_POSITIVE),
       1);
   // Mismatch:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType.NoSubmission",
-                                     AutofillMetrics::TYPE_MISMATCH, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_MISMATCH,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType.NoSubmission",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MISMATCH), 1);
+      GetFieldTypeGroupMetric(NAME_FULL,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
+      1);
 
   // Overall predictions:
   // Unknown:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.NoSubmission",
-      AutofillMetrics::TYPE_UNKNOWN, 1);
+      AutofillMetrics::FALSE_NEGATIVE_UNKNOWN, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType.NoSubmission",
       GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.NoSubmission",
-      AutofillMetrics::TYPE_MATCH, 2);
+      AutofillMetrics::TRUE_POSITIVE, 2);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType.NoSubmission",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MATCH), 1);
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TRUE_POSITIVE),
+      1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType.NoSubmission",
       GetFieldTypeGroupMetric(PHONE_HOME_WHOLE_NUMBER,
-                              AutofillMetrics::TYPE_MATCH),
+                              AutofillMetrics::TRUE_POSITIVE),
       1);
   // Mismatch:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.NoSubmission",
-      AutofillMetrics::TYPE_MISMATCH, 1);
+      AutofillMetrics::FALSE_NEGATIVE_MISMATCH, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType.NoSubmission",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MISMATCH), 1);
+      GetFieldTypeGroupMetric(NAME_FULL,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
+      1);
 }
 
 // Test that we log quality metrics for heuristics and server predictions based
 // on autocomplete attributes present on the fields.
 TEST_F(AutofillMetricsTest, QualityMetrics_BasedOnAutocomplete) {
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
   form.origin = GURL("http://myform.com/form.html");
   form.action = GURL("http://myform.com/submit.html");
 
@@ skipping 54 matching lines @@
   EXPECT_EQ(NAME_LAST, form_structure_ptr->field(0)->Type().GetStorableType());
   EXPECT_EQ(NAME_MIDDLE,
             form_structure_ptr->field(1)->Type().GetStorableType());
   EXPECT_EQ(ADDRESS_HOME_ZIP,
             form_structure_ptr->field(2)->Type().GetStorableType());
 
   // Heuristic predictions.
   // Unknown:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.BasedOnAutocomplete",
-      AutofillMetrics::TYPE_UNKNOWN, 1);
+      AutofillMetrics::FALSE_NEGATIVE_UNKNOWN, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType.BasedOnAutocomplete",
-      GetFieldTypeGroupMetric(ADDRESS_HOME_ZIP, AutofillMetrics::TYPE_UNKNOWN),
+      GetFieldTypeGroupMetric(ADDRESS_HOME_ZIP,
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.BasedOnAutocomplete",
-      AutofillMetrics::TYPE_MATCH, 1);
+      AutofillMetrics::TRUE_POSITIVE, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType.BasedOnAutocomplete",
-      GetFieldTypeGroupMetric(NAME_LAST, AutofillMetrics::TYPE_MATCH), 1);
+      GetFieldTypeGroupMetric(NAME_LAST, AutofillMetrics::TRUE_POSITIVE), 1);
   // Mismatch:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.BasedOnAutocomplete",
-      AutofillMetrics::TYPE_MISMATCH, 1);
+      AutofillMetrics::FALSE_NEGATIVE_MISMATCH, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType.BasedOnAutocomplete",
-      GetFieldTypeGroupMetric(NAME_MIDDLE, AutofillMetrics::TYPE_MISMATCH), 1);
+      GetFieldTypeGroupMetric(NAME_MIDDLE,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
+      1);
 
   // Server predictions.
   // Unknown:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.BasedOnAutocomplete",
-      AutofillMetrics::TYPE_UNKNOWN, 1);
+      AutofillMetrics::FALSE_NEGATIVE_UNKNOWN, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType.BasedOnAutocomplete",
-      GetFieldTypeGroupMetric(ADDRESS_HOME_ZIP, AutofillMetrics::TYPE_UNKNOWN),
+      GetFieldTypeGroupMetric(ADDRESS_HOME_ZIP,
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.BasedOnAutocomplete",
-      AutofillMetrics::TYPE_MATCH, 1);
+      AutofillMetrics::TRUE_POSITIVE, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType.BasedOnAutocomplete",
-      GetFieldTypeGroupMetric(NAME_LAST, AutofillMetrics::TYPE_MATCH), 1);
+      GetFieldTypeGroupMetric(NAME_LAST, AutofillMetrics::TRUE_POSITIVE), 1);
   // Mismatch:
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.BasedOnAutocomplete",
-      AutofillMetrics::TYPE_MISMATCH, 1);
+      AutofillMetrics::FALSE_NEGATIVE_MISMATCH, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType.BasedOnAutocomplete",
-      GetFieldTypeGroupMetric(NAME_MIDDLE, AutofillMetrics::TYPE_MISMATCH), 1);
+      GetFieldTypeGroupMetric(NAME_MIDDLE,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
+      1);
 }
 
 // Test that we log UPI Virtual Payment Address.
 TEST_F(AutofillMetricsTest, UpiVirtualPaymentAddress) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
 
@@ skipping 253 matching lines @@
     // (hence the values are not cleared in UpdateFromCache). The new values
     // match what is in the test profile.
     form.fields[1].value = base::ASCIIToUTF16("79401");
     form.fields[2].value = base::ASCIIToUTF16("2345678901");
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
 
     // First verify that country was not predicted by client or server.
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.ServerType.ByFieldType",
         GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                                AutofillMetrics::TYPE_UNKNOWN),
+                                AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
         1);
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.HeuristicType.ByFieldType",
         GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                                AutofillMetrics::TYPE_UNKNOWN),
+                                AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
         1);
     // We expect a match for country because it had |autocomplete_attribute|.
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.PredictedType.ByFieldType",
         GetFieldTypeGroupMetric(ADDRESS_HOME_COUNTRY,
-                                AutofillMetrics::TYPE_MATCH),
+                                AutofillMetrics::TRUE_POSITIVE),
         1);
 
     // We did not predict zip code or phone number, because they did not have
     // |autocomplete_attribute|, nor client or server predictions.
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.ServerType.ByFieldType",
         GetFieldTypeGroupMetric(ADDRESS_HOME_ZIP,
-                                AutofillMetrics::TYPE_UNKNOWN),
+                                AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
         1);
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.HeuristicType.ByFieldType",
         GetFieldTypeGroupMetric(ADDRESS_HOME_ZIP,
-                                AutofillMetrics::TYPE_UNKNOWN),
+                                AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
         1);
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.PredictedType.ByFieldType",
         GetFieldTypeGroupMetric(ADDRESS_HOME_ZIP,
-                                AutofillMetrics::TYPE_UNKNOWN),
+                                AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
         1);
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.ServerType.ByFieldType",
         GetFieldTypeGroupMetric(PHONE_HOME_WHOLE_NUMBER,
-                                AutofillMetrics::TYPE_UNKNOWN),
+                                AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
         1);
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.HeuristicType.ByFieldType",
         GetFieldTypeGroupMetric(PHONE_HOME_WHOLE_NUMBER,
-                                AutofillMetrics::TYPE_UNKNOWN),
+                                AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
         1);
     histogram_tester.ExpectBucketCount(
         "Autofill.Quality.PredictedType.ByFieldType",
         GetFieldTypeGroupMetric(PHONE_HOME_WHOLE_NUMBER,
-                                AutofillMetrics::TYPE_UNKNOWN),
+                                AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
         1);
 
     // Sanity check.
     histogram_tester.ExpectTotalCount("Autofill.Quality.PredictedType", 3);
   }
 }
 
 // Test that we behave sanely when the cached form differs from the submitted
 // one.
 TEST_F(AutofillMetricsTest, SaneMetricsWithCacheMismatch) {
@@ skipping 46 matching lines @@
   form.fields.push_back(cached_fields[3]);
   form.fields.push_back(cached_fields[0]);
 
   // Simulate form submission.
   base::HistogramTester histogram_tester;
   autofill_manager_->SubmitForm(form, TimeTicks::Now());
 
   // Heuristic predictions.
   // Unknown:
   histogram_tester.ExpectBucketCount("Autofill.Quality.HeuristicType",
-                                     AutofillMetrics::TYPE_UNKNOWN, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_UNKNOWN,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType",
       GetFieldTypeGroupMetric(ADDRESS_HOME_STATE,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount("Autofill.Quality.HeuristicType",
-                                     AutofillMetrics::TYPE_MATCH, 2);
+                                     AutofillMetrics::TRUE_POSITIVE, 2);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType",
-      GetFieldTypeGroupMetric(ADDRESS_HOME_CITY, AutofillMetrics::TYPE_MATCH),
+      GetFieldTypeGroupMetric(ADDRESS_HOME_CITY,
+                              AutofillMetrics::TRUE_POSITIVE),
       1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MATCH), 1);
+      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TRUE_POSITIVE), 1);
   // Mismatch:
   histogram_tester.ExpectBucketCount("Autofill.Quality.HeuristicType",
-                                     AutofillMetrics::TYPE_MISMATCH, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_MISMATCH,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.HeuristicType.ByFieldType",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MISMATCH),
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
       1);
 
   // Server predictions:
   // Unknown:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType",
-                                     AutofillMetrics::TYPE_UNKNOWN, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_UNKNOWN,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType",
       GetFieldTypeGroupMetric(ADDRESS_HOME_STATE,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType",
-                                     AutofillMetrics::TYPE_MATCH, 1);
+                                     AutofillMetrics::TRUE_POSITIVE, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MATCH), 1);
+      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TRUE_POSITIVE), 1);
   // Mismatch:
   histogram_tester.ExpectBucketCount("Autofill.Quality.ServerType",
-                                     AutofillMetrics::TYPE_MISMATCH, 2);
+                                     AutofillMetrics::FALSE_NEGATIVE_MISMATCH,
+                                     2);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType",
       GetFieldTypeGroupMetric(ADDRESS_HOME_CITY,
-                              AutofillMetrics::TYPE_MISMATCH),
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
       1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.ServerType.ByFieldType",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MISMATCH),
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
       1);
 
   // Overall predictions:
   // Unknown:
   histogram_tester.ExpectBucketCount("Autofill.Quality.PredictedType",
-                                     AutofillMetrics::TYPE_UNKNOWN, 1);
+                                     AutofillMetrics::FALSE_NEGATIVE_UNKNOWN,
+                                     1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType",
       GetFieldTypeGroupMetric(ADDRESS_HOME_STATE,
-                              AutofillMetrics::TYPE_UNKNOWN),
+                              AutofillMetrics::FALSE_NEGATIVE_UNKNOWN),
       1);
   // Match:
   histogram_tester.ExpectBucketCount("Autofill.Quality.PredictedType",
-                                     AutofillMetrics::TYPE_MATCH, 1);
+                                     AutofillMetrics::TRUE_POSITIVE, 1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType",
-      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TYPE_MATCH), 1);
+      GetFieldTypeGroupMetric(NAME_FULL, AutofillMetrics::TRUE_POSITIVE), 1);
   // Mismatch:
   histogram_tester.ExpectBucketCount("Autofill.Quality.PredictedType",
-                                     AutofillMetrics::TYPE_MISMATCH, 2);
+                                     AutofillMetrics::FALSE_NEGATIVE_MISMATCH,
+                                     2);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType",
       GetFieldTypeGroupMetric(ADDRESS_HOME_CITY,
-                              AutofillMetrics::TYPE_MISMATCH),
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
       1);
   histogram_tester.ExpectBucketCount(
       "Autofill.Quality.PredictedType.ByFieldType",
-      GetFieldTypeGroupMetric(EMAIL_ADDRESS, AutofillMetrics::TYPE_MISMATCH),
+      GetFieldTypeGroupMetric(EMAIL_ADDRESS,
+                              AutofillMetrics::FALSE_NEGATIVE_MISMATCH),
       1);
 }
 
 // Verify that when submitting an autofillable form, the stored profile metric
 // is logged.
 TEST_F(AutofillMetricsTest, StoredProfileCountAutofillableFormSubmission) {
   // Construct a fillable form.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
@@ skipping 3585 matching lines @@
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_NoUkmService) {
   ukm::TestUkmRecorder test_ukm_recorder;
   GURL url("https://www.google.com");
   std::vector<std::pair<const char*, int>> metrics = {{"metric", 1}};
 
   EXPECT_FALSE(AutofillMetrics::LogUkm(nullptr, url, "test_ukm", metrics));
   ASSERT_EQ(0U, test_ukm_recorder.sources_count());
 }
 
 }  // namespace autofill