[autofill] Add UKM for field type prediction quality and autofill outcome.

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 41 matching lines @@
 using base::Bucket;
 using base::TimeTicks;
 using rappor::TestRapporServiceImpl;
 using ::testing::ElementsAre;
 using ::testing::Matcher;
 using ::testing::UnorderedPointwise;
 
 namespace autofill {
 namespace {
 
+using ExpectedUkmMetrics =
+    std::vector<std::vector<std::pair<const char*, int64_t>>>;
+
 class TestPersonalDataManager : public PersonalDataManager {
  public:
   TestPersonalDataManager()
       : PersonalDataManager("en-US"),
         autofill_enabled_(true) {
     CreateTestAutofillProfiles(&web_profiles_);
   }
 
   using PersonalDataManager::set_account_tracker;
   using PersonalDataManager::set_signin_manager;
@@ skipping 264 matching lines @@
 };
 
 MATCHER(CompareMetrics, "") {
   const ukm::mojom::UkmMetric* lhs = ::testing::get<0>(arg).get();
   const std::pair<const char*, int64_t>& rhs = ::testing::get<1>(arg);
   return lhs->metric_hash == base::HashMetricName(rhs.first) &&
          lhs->value == rhs.second;
 }
 
 void VerifyDeveloperEngagementUkm(
+    const ukm::TestUkmRecorder& ukm_recorder,
     const FormData& form,
-    const ukm::TestUkmRecorder* ukm_recorder,
     const std::vector<int64_t>& expected_metric_values) {
-  const ukm::mojom::UkmEntry* entry = ukm_recorder->GetEntryForEntryName(
+  const ukm::mojom::UkmEntry* entry = ukm_recorder.GetEntryForEntryName(
       internal::kUKMDeveloperEngagementEntryName);
   ASSERT_NE(nullptr, entry);
   const ukm::UkmSource* source =
-      ukm_recorder->GetSourceForSourceId(entry->source_id);
+      ukm_recorder.GetSourceForSourceId(entry->source_id);
   ASSERT_NE(nullptr, source);
   EXPECT_EQ(form.origin, source->url());
 
   int expected_metric_value = 0;
   for (const auto it : expected_metric_values)
     expected_metric_value |= 1 << it;
 
   const std::vector<std::pair<const char*, int64_t>> expected_metrics{
       {internal::kUKMDeveloperEngagementMetricName, expected_metric_value}};
 
   EXPECT_THAT(entry->metrics,
               UnorderedPointwise(CompareMetrics(), expected_metrics));
 }
 
 MATCHER(CompareMetricsIgnoringMillisecondsSinceFormParsed, "") {
   const ukm::mojom::UkmMetric* lhs = ::testing::get<0>(arg).get();
   const std::pair<const char*, int64_t>& rhs = ::testing::get<1>(arg);
   return lhs->metric_hash == base::HashMetricName(rhs.first) &&
          (lhs->value == rhs.second ||
           (lhs->value > 0 &&
            rhs.first == internal::kUKMMillisecondsSinceFormParsedMetricName));
 }
 
-void VerifyFormInteractionUkm(
-    const FormData& form,
-    const ukm::TestUkmRecorder* ukm_recorder,
-    const char* event_name,
-    const std::vector<std::vector<std::pair<const char*, int64_t>>>&
-        expected_metrics) {
+void VerifyFormInteractionUkm(const ukm::TestUkmRecorder& ukm_recorder,
+                              const FormData& form,
+                              const char* event_name,
+                              const ExpectedUkmMetrics& expected_metrics) {
   size_t expected_metrics_index = 0;
-  for (size_t i = 0; i < ukm_recorder->entries_count(); ++i) {
-    const ukm::mojom::UkmEntry* entry = ukm_recorder->GetEntry(i);
+  for (size_t i = 0; i < ukm_recorder.entries_count(); ++i) {
+    const ukm::mojom::UkmEntry* entry = ukm_recorder.GetEntry(i);
     if (entry->event_hash != base::HashMetricName(event_name))
       continue;
 
     const ukm::UkmSource* source =
-        ukm_recorder->GetSourceForSourceId(entry->source_id);
+        ukm_recorder.GetSourceForSourceId(entry->source_id);
     ASSERT_NE(nullptr, source);
     EXPECT_EQ(form.origin, source->url());
 
     ASSERT_LT(expected_metrics_index, expected_metrics.size());
     EXPECT_THAT(
         entry->metrics,
         UnorderedPointwise(CompareMetricsIgnoringMillisecondsSinceFormParsed(),
                            expected_metrics[expected_metrics_index++]));
   }
 }
 
-void VerifySubmitFormUkm(const FormData& form,
-                         const ukm::TestUkmRecorder* ukm_recorder,
+void VerifySubmitFormUkm(const ukm::TestUkmRecorder& ukm_recorder,
+                         const FormData& form,
                          AutofillMetrics::AutofillFormSubmittedState state) {
   VerifyFormInteractionUkm(
-      form, ukm_recorder, internal::kUKMFormSubmittedEntryName,
+      ukm_recorder, form, internal::kUKMFormSubmittedEntryName,
       {{{internal::kUKMAutofillFormSubmittedStateMetricName, state},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
 }
 
+void AppendFieldFillStatusUkm(const FormData& form,
+                              ExpectedUkmMetrics* expected_metrics) {
+  int64_t form_signature = static_cast<int64_t>(CalculateFormSignature(form));
+  int64_t metric_type = static_cast<int64_t>(AutofillMetrics::TYPE_SUBMISSION);
+  for (const FormFieldData& field : form.fields) {
+    int64_t field_signature =
+        static_cast<int64_t>(CalculateFieldSignatureForField(field));
+    expected_metrics->push_back(
+        {{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
+         {internal::kUKMFormSignatureMetricName, form_signature},
+         {internal::kUKMFieldSignatureMetricName, field_signature},
+         {internal::kUKMValidationEventMetricName, metric_type},
+         {internal::kUKMIsAutofilledMetricName, field.is_autofilled ? 1 : 0},
+         {internal::kUKMWasPreviouslyAutofilledMetricName, 0}});
+  }
+}
+
+void AppendFieldTypeUkm(const FormData& form,
+                        const std::vector<ServerFieldType>& heuristic_types,
+                        const std::vector<ServerFieldType>& server_types,
+                        const std::vector<ServerFieldType>& actual_types,
+                        ExpectedUkmMetrics* expected_metrics) {
+  ASSERT_EQ(heuristic_types.size(), form.fields.size());
+  ASSERT_EQ(server_types.size(), form.fields.size());
+  ASSERT_EQ(actual_types.size(), form.fields.size());
+  int64_t form_signature = static_cast<int64_t>(CalculateFormSignature(form));
+  int64_t metric_type = static_cast<int64_t>(AutofillMetrics::TYPE_SUBMISSION);
+  std::vector<int64_t> prediction_sources{
+      AutofillMetrics::PREDICTION_SOURCE_HEURISTIC,
+      AutofillMetrics::PREDICTION_SOURCE_SERVER,
+      AutofillMetrics::PREDICTION_SOURCE_OVERALL};
+  for (size_t i = 0; i < form.fields.size(); ++i) {
+    const FormFieldData& field = form.fields[i];
+    int64_t field_signature =
+        static_cast<int64_t>(CalculateFieldSignatureForField(field));
+    for (int64_t source : prediction_sources) {
+      int64_t predicted_type = static_cast<int64_t>(
+          (source == AutofillMetrics::PREDICTION_SOURCE_SERVER
+               ? server_types
+               : heuristic_types)[i]);
+      int64_t actual_type = static_cast<int64_t>(actual_types[i]);
+      expected_metrics->push_back(
+          {{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
+           {internal::kUKMFormSignatureMetricName, form_signature},
+           {internal::kUKMFieldSignatureMetricName, field_signature},
+           {internal::kUKMValidationEventMetricName, metric_type},
+           {internal::kUKMPredictionSourceMetricName, source},
+           {internal::kUKMPredictedTypeMetricName, predicted_type},
+           {internal::kUKMActualTypeMetricName, actual_type}});
+    }
+  }
+}
+
 }  // namespace
 
 // This is defined in the autofill_metrics.cc implementation file.
 int GetFieldTypeGroupMetric(ServerFieldType field_type,
                             AutofillMetrics::FieldTypeQualityMetric metric);
 
 class AutofillMetricsTest : public testing::Test {
  public:
   ~AutofillMetricsTest() override;
 
@@ skipping 381 matching lines @@
   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;
+  std::vector<ServerFieldType> heuristic_types, server_types, actual_types;
   AutofillField field;
 
   // Add a first name field, that is predicted correctly.
   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);
+  actual_types.push_back(NAME_FIRST);
 
   // Add a last name field, that is predicted correctly.
   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);
+  actual_types.push_back(NAME_LAST);
 
   // Add an empty or unknown field, that is predicted as per the test params.
   test::CreateTestFormField("Unknown", "Unknown",
                             ValueForType(actual_field_type), "text", &field);
   form.fields.push_back(field);
   heuristic_types.push_back(predicted_type);
   server_types.push_back(predicted_type == UNKNOWN_TYPE ? NO_SERVER_DATA
                                                         : predicted_type);
+  // Resolve any field type ambiguity.
+  if (actual_field_type == AMBIGUOUS_TYPE) {
+    if (predicted_type == COMPANY_NAME || predicted_type == NAME_MIDDLE)
+      actual_field_type = predicted_type;
+  }
+  actual_types.push_back(actual_field_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());
 
-  // Resolve any field type ambiguity.
-  if (actual_field_type == AMBIGUOUS_TYPE) {
-    if (predicted_type == COMPANY_NAME || predicted_type == NAME_MIDDLE)
-      actual_field_type = predicted_type;
-  }
+  ExpectedUkmMetrics expected_ukm_metrics;
+  AppendFieldTypeUkm(form, heuristic_types, server_types, actual_types,
+                     &expected_ukm_metrics);
+  VerifyFormInteractionUkm(test_ukm_recorder_, form,
+                           internal::kUKMFieldTypeEntryName,
+                           expected_ukm_metrics);
 
   // Validate the total samples and the crossed (predicted-to-actual) samples.
   for (const auto& source : prediction_sources) {
     const std::string crossed_histogram = "Autofill.FieldPrediction." + source;
     const std::string aggregate_histogram =
         "Autofill.FieldPredictionQuality.Aggregate." + source;
     const std::string by_field_type_histogram =
         "Autofill.FieldPredictionQuality.ByFieldType." + source;
 
     // Sanity Check:
@@ skipping 924 matching lines @@
 
   // Expect the "form parsed without field type hints" metric and the
   // "form loaded" form interaction event to be logged.
   {
     autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
     ASSERT_EQ(1U, test_ukm_recorder_.entries_count());
     ASSERT_EQ(1U, test_ukm_recorder_.sources_count());
     VerifyDeveloperEngagementUkm(
-        form, &test_ukm_recorder_,
+        test_ukm_recorder_, form,
         {AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS});
   }
 }
 
 // Verify that we correctly log UKM for form parsed with type hints regarding
 // developer engagement.
 TEST_F(AutofillMetricsTest,
        UkmDeveloperEngagement_LogFillableFormParsedWithTypeHints) {
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
@@ skipping 29 matching lines @@
 
   // Expect the "form parsed without field type hints" metric and the
   // "form loaded" form interaction event to be logged.
   {
     autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
     ASSERT_EQ(1U, test_ukm_recorder_.entries_count());
     ASSERT_EQ(1U, test_ukm_recorder_.sources_count());
     VerifyDeveloperEngagementUkm(
-        form, &test_ukm_recorder_,
+        test_ukm_recorder_, form,
         {AutofillMetrics::FILLABLE_FORM_PARSED_WITH_TYPE_HINTS});
   }
 }
 
 // Verify that we correctly log UKM for form parsed with type hints regarding
 // developer engagement.
 TEST_F(AutofillMetricsTest, UkmDeveloperEngagement_LogUpiVpaTypeHint) {
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
@@ skipping 11 matching lines @@
   std::vector<FormData> forms(1, form);
 
   // Expect the "upi-vpa hint" metric to be logged and the "form loaded" form
   // interaction event to be logged.
   {
     autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
     ASSERT_EQ(1U, test_ukm_recorder_.entries_count());
     ASSERT_EQ(1U, test_ukm_recorder_.sources_count());
-    VerifyDeveloperEngagementUkm(form, &test_ukm_recorder_,
+    VerifyDeveloperEngagementUkm(test_ukm_recorder_, form,
                                  {AutofillMetrics::FORM_CONTAINS_UPI_VPA_HINT});
     test_ukm_recorder_.Purge();
   }
 
   // Add another field with an author-specified field type to the form.
   test::CreateTestFormField("", "", "", "text", &field);
   field.autocomplete_attribute = "address-line1";
   forms.back().fields.push_back(field);
 
   {
     autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
     VerifyDeveloperEngagementUkm(
-        form, &test_ukm_recorder_,
+        test_ukm_recorder_, form,
         {AutofillMetrics::FILLABLE_FORM_PARSED_WITH_TYPE_HINTS,
          AutofillMetrics::FORM_CONTAINS_UPI_VPA_HINT});
   }
 }
 
 // Test that the profile count is logged correctly.
 TEST_F(AutofillMetricsTest, StoredProfileCount) {
   // The metric should be logged when the profiles are first loaded.
   {
     base::HistogramTester histogram_tester;
@@ skipping 252 matching lines @@
     base::UserActionTester user_action_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     EXPECT_EQ(1,
               user_action_tester.GetActionCount("Autofill_OnWillSubmitForm"));
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_NonFillable"));
   }
 
   VerifyFormInteractionUkm(
-      form, &test_ukm_recorder_, internal::kUKMSuggestionsShownEntryName,
+      test_ukm_recorder_, form, internal::kUKMSuggestionsShownEntryName,
       {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
         {internal::kUKMHeuristicTypeMetricName, CREDIT_CARD_NAME_FULL},
         {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
         {internal::kUKMServerTypeMetricName, CREDIT_CARD_NAME_FULL}},
        {{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
         {internal::kUKMHeuristicTypeMetricName, CREDIT_CARD_NUMBER},
         {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
         {internal::kUKMServerTypeMetricName, CREDIT_CARD_NUMBER}}});
   // Expect 2 |FORM_EVENT_LOCAL_SUGGESTION_FILLED| events. First, from
   // call to |external_delegate_->DidAcceptSuggestion|. Second, from call to
   // |autofill_manager_->FillOrPreviewForm|.
   VerifyFormInteractionUkm(
-      form, &test_ukm_recorder_, internal::kUKMSuggestionFilledEntryName,
+      test_ukm_recorder_, form, internal::kUKMSuggestionFilledEntryName,
       {{{internal::kUKMRecordTypeMetricName, CreditCard::LOCAL_CARD},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}},
        {{internal::kUKMRecordTypeMetricName, CreditCard::LOCAL_CARD},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
   // Expect |NON_FILLABLE_FORM_OR_NEW_DATA| in |AutofillFormSubmittedState|
   // because |field.value| is empty in |DeterminePossibleFieldTypesForUpload|.
-  VerifySubmitFormUkm(form, &test_ukm_recorder_,
+  VerifySubmitFormUkm(test_ukm_recorder_, form,
                       AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
 }
 
 // Test that the profile checkout flow user actions are correctly logged.
 TEST_F(AutofillMetricsTest, ProfileCheckoutFlowUserActions) {
   // Create a profile.
   personal_data_->RecreateProfile();
 
   // Set up our form data.
   FormData form;
@@ skipping 70 matching lines @@
     base::UserActionTester user_action_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     EXPECT_EQ(1,
               user_action_tester.GetActionCount("Autofill_OnWillSubmitForm"));
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_NonFillable"));
   }
 
   VerifyFormInteractionUkm(
-      form, &test_ukm_recorder_, internal::kUKMSuggestionsShownEntryName,
+      test_ukm_recorder_, form, internal::kUKMSuggestionsShownEntryName,
       {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
         {internal::kUKMHeuristicTypeMetricName, ADDRESS_HOME_STATE},
         {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
         {internal::kUKMServerTypeMetricName, ADDRESS_HOME_STATE}},
        {{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
         {internal::kUKMHeuristicTypeMetricName, ADDRESS_HOME_CITY},
         {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
         {internal::kUKMServerTypeMetricName, ADDRESS_HOME_CITY}}});
   // Expect 2 |FORM_EVENT_LOCAL_SUGGESTION_FILLED| events. First, from
   // call to |external_delegate_->DidAcceptSuggestion|. Second, from call to
   // |autofill_manager_->FillOrPreviewForm|.
   VerifyFormInteractionUkm(
-      form, &test_ukm_recorder_, internal::kUKMSuggestionFilledEntryName,
+      test_ukm_recorder_, form, internal::kUKMSuggestionFilledEntryName,
       {{{internal::kUKMRecordTypeMetricName, AutofillProfile::LOCAL_PROFILE},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}},
        {{internal::kUKMRecordTypeMetricName, AutofillProfile::LOCAL_PROFILE},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
   // Expect |NON_FILLABLE_FORM_OR_NEW_DATA| in |AutofillFormSubmittedState|
   // because |field.value| is empty in |DeterminePossibleFieldTypesForUpload|.
-  VerifySubmitFormUkm(form, &test_ukm_recorder_,
+  VerifySubmitFormUkm(test_ukm_recorder_, form,
                       AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
 }
 
 // Tests that the Autofill_PolledCreditCardSuggestions user action is only
 // logged once if the field is queried repeatedly.
 TEST_F(AutofillMetricsTest, PolledCreditCardSuggestions_DebounceLogs) {
   personal_data_->RecreateCreditCards(
       true /* include_local_credit_card */,
       false /* include_masked_server_credit_card */,
       false /* include_full_server_credit_card */);
@@ skipping 690 matching lines @@
     base::HistogramTester histogram_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_NO_SUGGESTION_WILL_SUBMIT_ONCE, 1);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_NO_SUGGESTION_SUBMITTED_ONCE, 1);
 
-    VerifySubmitFormUkm(form, &test_ukm_recorder_,
+    VerifySubmitFormUkm(test_ukm_recorder_, form,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
   test_ukm_recorder_.Purge();
 
   autofill_manager_->AddSeenForm(form, field_types, field_types);
 
   {
     // Simulating submission with suggestion shown.
     base::HistogramTester histogram_tester;
     autofill_manager_->DidShowSuggestions(true /* is_new_popup */, form, field);
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_SUGGESTION_SHOWN_SUBMITTED_ONCE, 1);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_SUGGESTION_SHOWN_WILL_SUBMIT_ONCE, 1);
 
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_, internal::kUKMSuggestionsShownEntryName,
+        test_ukm_recorder_, form, internal::kUKMSuggestionsShownEntryName,
         {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
           {internal::kUKMHeuristicTypeMetricName, CREDIT_CARD_NUMBER},
           {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
           {internal::kUKMServerTypeMetricName, CREDIT_CARD_NUMBER}}});
-    VerifySubmitFormUkm(form, &test_ukm_recorder_,
+    VerifySubmitFormUkm(test_ukm_recorder_, form,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
   test_ukm_recorder_.Purge();
 
   autofill_manager_->AddSeenForm(form, field_types, field_types);
 
   {
     // Simulating submission with filled local data.
     base::HistogramTester histogram_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     std::string guid("10000000-0000-0000-0000-000000000001");  // local card
     autofill_manager_->FillOrPreviewForm(
         AutofillDriver::FORM_DATA_ACTION_FILL, 0, form, form.fields.front(),
         autofill_manager_->MakeFrontendID(guid, std::string()));
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_WILL_SUBMIT_ONCE, 1);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_SUBMITTED_ONCE, 1);
 
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_, internal::kUKMSuggestionFilledEntryName,
+        test_ukm_recorder_, form, internal::kUKMSuggestionFilledEntryName,
         {{{internal::kUKMRecordTypeMetricName, CreditCard::LOCAL_CARD},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
-    VerifySubmitFormUkm(form, &test_ukm_recorder_,
+    VerifySubmitFormUkm(test_ukm_recorder_, form,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
   test_ukm_recorder_.Purge();
 
   autofill_manager_->AddSeenForm(form, field_types, field_types);
 
   {
     // Simulating submission with filled server data.
     base::HistogramTester histogram_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     std::string guid(
         "10000000-0000-0000-0000-000000000003");  // full server card
     autofill_manager_->FillOrPreviewForm(
         AutofillDriver::FORM_DATA_ACTION_FILL, 0, form, form.fields.front(),
         autofill_manager_->MakeFrontendID(guid, std::string()));
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_WILL_SUBMIT_ONCE, 1);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_SUBMITTED_ONCE, 1);
 
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_, internal::kUKMSuggestionFilledEntryName,
+        test_ukm_recorder_, form, internal::kUKMSuggestionFilledEntryName,
         {{{internal::kUKMRecordTypeMetricName, CreditCard::FULL_SERVER_CARD},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
-    VerifySubmitFormUkm(form, &test_ukm_recorder_,
+    VerifySubmitFormUkm(test_ukm_recorder_, form,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
   test_ukm_recorder_.Purge();
 
   autofill_manager_->AddSeenForm(form, field_types, field_types);
 
   {
     // Simulating submission with a masked card server suggestion.
     base::HistogramTester histogram_tester;
     std::string guid(
         "10000000-0000-0000-0000-000000000002");  // masked server card
     autofill_manager_->FillOrPreviewForm(
         AutofillDriver::FORM_DATA_ACTION_FILL, 0, form, form.fields.back(),
         autofill_manager_->MakeFrontendID(guid, std::string()));
     autofill_manager_->OnDidGetRealPan(AutofillClient::SUCCESS,
                                        "6011000990139424");
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_FILLED, 1);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_FILLED_ONCE,
         1);
 
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_, internal::kUKMSuggestionFilledEntryName,
+        test_ukm_recorder_, form, internal::kUKMSuggestionFilledEntryName,
         {{{internal::kUKMRecordTypeMetricName, CreditCard::MASKED_SERVER_CARD},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_,
+        test_ukm_recorder_, form,
         internal::kUKMSelectedMaskedServerCardEntryName,
         {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
-    VerifySubmitFormUkm(form, &test_ukm_recorder_,
+    VerifySubmitFormUkm(test_ukm_recorder_, form,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
   test_ukm_recorder_.Purge();
 
   // Recreating cards as the previous test should have upgraded the masked
   // card to a full card.
   personal_data_->RecreateCreditCards(
       true /* include_local_credit_card */,
       true /* include_masked_server_credit_card */,
       true /* include_full_server_credit_card */);
 
   // Reset the autofill manager state.
   autofill_manager_->Reset();
   autofill_manager_->AddSeenForm(form, field_types, field_types);
 
   {
     // Simulating multiple submissions.
     base::HistogramTester histogram_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
 
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_, internal::kUKMFormSubmittedEntryName,
+        test_ukm_recorder_, form, internal::kUKMFormSubmittedEntryName,
         {{{internal::kUKMAutofillFormSubmittedStateMetricName,
            AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
 
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
 
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_, internal::kUKMFormSubmittedEntryName,
+        test_ukm_recorder_, form, internal::kUKMFormSubmittedEntryName,
         {{{internal::kUKMAutofillFormSubmittedStateMetricName,
            AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}},
          {{internal::kUKMAutofillFormSubmittedStateMetricName,
            AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
 
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_NO_SUGGESTION_WILL_SUBMIT_ONCE, 1);
@@ skipping 71 matching lines @@
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_WILL_SUBMIT_ONCE, 0);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::
             FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_WILL_SUBMIT_ONCE,
         0);
 
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_, internal::kUKMSuggestionsShownEntryName,
+        test_ukm_recorder_, form, internal::kUKMSuggestionsShownEntryName,
         {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
           {internal::kUKMHeuristicTypeMetricName, CREDIT_CARD_NUMBER},
           {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
           {internal::kUKMServerTypeMetricName, CREDIT_CARD_NUMBER}}});
-    VerifySubmitFormUkm(form, &test_ukm_recorder_,
+    VerifySubmitFormUkm(test_ukm_recorder_, form,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 }
 
 // Test that we log "will submit" (but not submitted) form events for credit
 // cards. Mirrors CreditCardSubmittedFormEvents test but does not expect any
 // "submitted" metrics.
 TEST_F(AutofillMetricsTest, CreditCardWillSubmitFormEvents) {
   EnableWalletSync();
   // Creating all kinds of cards.
@@ skipping 454 matching lines @@
     base::HistogramTester histogram_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.Address",
         AutofillMetrics::FORM_EVENT_NO_SUGGESTION_WILL_SUBMIT_ONCE, 1);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.Address",
         AutofillMetrics::FORM_EVENT_NO_SUGGESTION_SUBMITTED_ONCE, 1);
 
-    VerifySubmitFormUkm(form, &test_ukm_recorder_,
+    VerifySubmitFormUkm(test_ukm_recorder_, form,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
   test_ukm_recorder_.Purge();
 
   autofill_manager_->AddSeenForm(form, field_types, field_types);
 
   {
@@ skipping 502 matching lines @@
   form.fields.push_back(field);
   test::CreateTestFormField("Unknown", "unknown", "", "text", &field);
   form.fields.push_back(field);
   std::vector<FormData> forms(1, form);
 
   // Expect no notifications when the form is first seen.
   {
     base::HistogramTester histogram_tester;
     autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     histogram_tester.ExpectTotalCount("Autofill.FormSubmittedState", 0);
+
+    EXPECT_EQ(1U, test_ukm_recorder_.entries_count());
+    EXPECT_EQ(1U, test_ukm_recorder_.sources_count());
+
+    VerifyDeveloperEngagementUkm(
+        test_ukm_recorder_, form,
+        {AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS});
   }
 
-  std::vector<std::vector<std::pair<const char*, int64_t>>>
-      expected_form_submission_ukm_metrics = {
-          {{internal::kUKMAutofillFormSubmittedStateMetricName,
-            AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA},
-           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}};
+  ExpectedUkmMetrics expected_form_submission_ukm_metrics;
+  ExpectedUkmMetrics expected_field_fill_status_ukm_metrics;
 
   // No data entered in the form.
   {
     base::HistogramTester histogram_tester;
     base::UserActionTester user_action_tester;
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectUniqueSample(
         "Autofill.FormSubmittedState",
         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA, 1);
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_NonFillable"));
 
-    // Expect an entry for |DeveloperEngagement| and an entry for form
-    // interactions. Both entries are for the same URL.
-    ASSERT_EQ(2U, test_ukm_recorder_.entries_count());
-    ASSERT_EQ(2U, test_ukm_recorder_.sources_count());
-    VerifyDeveloperEngagementUkm(
-        form, &test_ukm_recorder_,
-        {AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS});
-    VerifyFormInteractionUkm(form, &test_ukm_recorder_,
+    expected_form_submission_ukm_metrics.push_back(
+        {{internal::kUKMAutofillFormSubmittedStateMetricName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA},
+         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}});
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_ukm_metrics);
+
+    AppendFieldFillStatusUkm(form, &expected_field_fill_status_ukm_metrics);
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
+                             internal::kUKMFieldFillStatusEntryName,
+                             expected_field_fill_status_ukm_metrics);
   }
 
   // Non fillable form.
   form.fields[0].value = ASCIIToUTF16("Elvis Aaron Presley");
   form.fields[1].value = ASCIIToUTF16("theking@gmail.com");
   forms.front() = form;
 
   {
     base::HistogramTester histogram_tester;
     base::UserActionTester user_action_tester;
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectUniqueSample(
         "Autofill.FormSubmittedState",
         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA, 1);
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_NonFillable"));
 
     expected_form_submission_ukm_metrics.push_back(
         {{internal::kUKMAutofillFormSubmittedStateMetricName,
           AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA},
          {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}});
-    VerifyFormInteractionUkm(form, &test_ukm_recorder_,
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_ukm_metrics);
+
+    AppendFieldFillStatusUkm(form, &expected_field_fill_status_ukm_metrics);
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
+                             internal::kUKMFieldFillStatusEntryName,
+                             expected_field_fill_status_ukm_metrics);
   }
 
   // Fill in the third field.
   form.fields[2].value = ASCIIToUTF16("12345678901");
   forms.front() = form;
 
   // Autofilled none with no suggestions shown.
   {
     base::HistogramTester histogram_tester;
     base::UserActionTester user_action_tester;
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectUniqueSample(
         "Autofill.FormSubmittedState",
         AutofillMetrics::FILLABLE_FORM_AUTOFILLED_NONE_DID_NOT_SHOW_SUGGESTIONS,
         1);
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_FilledNone_SuggestionsNotShown"));
 
     expected_form_submission_ukm_metrics.push_back(
         {{internal::kUKMAutofillFormSubmittedStateMetricName,
           AutofillMetrics::
               FILLABLE_FORM_AUTOFILLED_NONE_DID_NOT_SHOW_SUGGESTIONS},
          {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}});
-    VerifyFormInteractionUkm(form, &test_ukm_recorder_,
+
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_ukm_metrics);
+
+    AppendFieldFillStatusUkm(form, &expected_field_fill_status_ukm_metrics);
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
+                             internal::kUKMFieldFillStatusEntryName,
+                             expected_field_fill_status_ukm_metrics);
   }
 
   // Autofilled none with suggestions shown.
   autofill_manager_->DidShowSuggestions(true, form, form.fields[2]);
   {
     base::HistogramTester histogram_tester;
     base::UserActionTester user_action_tester;
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectUniqueSample(
         "Autofill.FormSubmittedState",
         AutofillMetrics::FILLABLE_FORM_AUTOFILLED_NONE_DID_SHOW_SUGGESTIONS, 1);
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_FilledNone_SuggestionsShown"));
 
     VerifyFormInteractionUkm(
-        form, &test_ukm_recorder_, internal::kUKMSuggestionsShownEntryName,
+        test_ukm_recorder_, form, internal::kUKMSuggestionsShownEntryName,
         {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
           {internal::kUKMHeuristicTypeMetricName, PHONE_HOME_WHOLE_NUMBER},
           {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
           {internal::kUKMServerTypeMetricName, NO_SERVER_DATA}}});
+
     expected_form_submission_ukm_metrics.push_back(
         {{internal::kUKMAutofillFormSubmittedStateMetricName,
           AutofillMetrics::FILLABLE_FORM_AUTOFILLED_NONE_DID_SHOW_SUGGESTIONS},
          {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}});
-    VerifyFormInteractionUkm(form, &test_ukm_recorder_,
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_ukm_metrics);
+
+    AppendFieldFillStatusUkm(form, &expected_field_fill_status_ukm_metrics);
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
+                             internal::kUKMFieldFillStatusEntryName,
+                             expected_field_fill_status_ukm_metrics);
   }
 
   // Mark one of the fields as autofilled.
   form.fields[1].is_autofilled = true;
   forms.front() = form;
 
   // Autofilled some of the fields.
   {
     base::HistogramTester histogram_tester;
     base::UserActionTester user_action_tester;
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectUniqueSample(
         "Autofill.FormSubmittedState",
         AutofillMetrics::FILLABLE_FORM_AUTOFILLED_SOME, 1);
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_FilledSome"));
 
     expected_form_submission_ukm_metrics.push_back(
         {{internal::kUKMAutofillFormSubmittedStateMetricName,
           AutofillMetrics::FILLABLE_FORM_AUTOFILLED_SOME},
          {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}});
-    VerifyFormInteractionUkm(form, &test_ukm_recorder_,
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_ukm_metrics);
+
+    AppendFieldFillStatusUkm(form, &expected_field_fill_status_ukm_metrics);
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
+                             internal::kUKMFieldFillStatusEntryName,
+                             expected_field_fill_status_ukm_metrics);
   }
 
   // Mark all of the fillable fields as autofilled.
   form.fields[0].is_autofilled = true;
   form.fields[2].is_autofilled = true;
   forms.front() = form;
 
   // Autofilled all the fields.
   {
     base::HistogramTester histogram_tester;
     base::UserActionTester user_action_tester;
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectUniqueSample(
         "Autofill.FormSubmittedState",
         AutofillMetrics::FILLABLE_FORM_AUTOFILLED_ALL, 1);
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_FilledAll"));
 
     expected_form_submission_ukm_metrics.push_back(
         {{internal::kUKMAutofillFormSubmittedStateMetricName,
           AutofillMetrics::FILLABLE_FORM_AUTOFILLED_ALL},
          {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}});
-    VerifyFormInteractionUkm(form, &test_ukm_recorder_,
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_ukm_metrics);
+
+    AppendFieldFillStatusUkm(form, &expected_field_fill_status_ukm_metrics);
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
+                             internal::kUKMFieldFillStatusEntryName,
+                             expected_field_fill_status_ukm_metrics);
   }
 
   // Clear out the third field's value.
   form.fields[2].value = base::string16();
   forms.front() = form;
 
   // Non fillable form.
   {
     base::HistogramTester histogram_tester;
     base::UserActionTester user_action_tester;
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectUniqueSample(
         "Autofill.FormSubmittedState",
         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA, 1);
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FormSubmitted_NonFillable"));
 
     expected_form_submission_ukm_metrics.push_back(
         {{internal::kUKMAutofillFormSubmittedStateMetricName,
           AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA},
          {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}});
-    VerifyFormInteractionUkm(form, &test_ukm_recorder_,
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_ukm_metrics);
+
+    AppendFieldFillStatusUkm(form, &expected_field_fill_status_ukm_metrics);
+    VerifyFormInteractionUkm(test_ukm_recorder_, form,
+                             internal::kUKMFieldFillStatusEntryName,
+                             expected_field_fill_status_ukm_metrics);
   }
 }
 
 // Verify that we correctly log user happiness metrics dealing with form
 // interaction.
 TEST_F(AutofillMetricsTest, UserHappinessFormInteraction) {
   // Load a fillable form.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
@@ skipping 90 matching lines @@
     autofill_manager_->OnTextFieldDidChange(form, form.fields[1], gfx::RectF(),
                                             TimeTicks());
     histogram_tester.ExpectUniqueSample(
         "Autofill.UserHappiness",
         AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD, 1);
   }
 
   autofill_manager_->Reset();
 
   VerifyFormInteractionUkm(
-      form, &test_ukm_recorder_, internal::kUKMInteractedWithFormEntryName,
+      test_ukm_recorder_, form, internal::kUKMInteractedWithFormEntryName,
       {{{internal::kUKMIsForCreditCardMetricName, false},
         {internal::kUKMLocalRecordTypeCountMetricName, 0},
         {internal::kUKMServerRecordTypeCountMetricName, 0}}});
   VerifyFormInteractionUkm(
-      form, &test_ukm_recorder_, internal::kUKMSuggestionsShownEntryName,
+      test_ukm_recorder_, form, internal::kUKMSuggestionsShownEntryName,
       {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
         {internal::kUKMHeuristicTypeMetricName, PHONE_HOME_WHOLE_NUMBER},
         {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
         {internal::kUKMServerTypeMetricName, NO_SERVER_DATA}},
        {{internal::kUKMMillisecondsSinceFormParsedMetricName, 0},
         {internal::kUKMHeuristicTypeMetricName, EMAIL_ADDRESS},
         {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
         {internal::kUKMServerTypeMetricName, NO_SERVER_DATA}}});
   VerifyFormInteractionUkm(
-      form, &test_ukm_recorder_, internal::kUKMSuggestionFilledEntryName,
+      test_ukm_recorder_, form, internal::kUKMSuggestionFilledEntryName,
       {{{internal::kUKMRecordTypeMetricName, AutofillProfile::LOCAL_PROFILE},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}},
        {{internal::kUKMRecordTypeMetricName, AutofillProfile::LOCAL_PROFILE},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
   VerifyFormInteractionUkm(
-      form, &test_ukm_recorder_, internal::kUKMTextFieldDidChangeEntryName,
+      test_ukm_recorder_, form, internal::kUKMTextFieldDidChangeEntryName,
       {{{internal::kUKMFieldTypeGroupMetricName, NAME},
         {internal::kUKMHeuristicTypeMetricName, NAME_FULL},
         {internal::kUKMServerTypeMetricName, NO_SERVER_DATA},
         {internal::kUKMHtmlFieldTypeMetricName, HTML_TYPE_UNSPECIFIED},
         {internal::kUKMHtmlFieldModeMetricName, HTML_MODE_NONE},
         {internal::kUKMIsAutofilledMetricName, false},
         {internal::kUKMIsEmptyMetricName, true},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}},
        {{internal::kUKMFieldTypeGroupMetricName, NAME},
         {internal::kUKMHeuristicTypeMetricName, NAME_FULL},
@@ skipping 672 matching lines @@
 // Tests that no UKM is logged when the ukm service is null.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_NoUkmService) {
   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