[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 250 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,

[sebsg, 2017/06/19 14:48:09]

What's the advantage of putting it first?

[Roger McFarlane (Chromium), 2017/06/21 21:01:54]

nothing in particular. mostly just a preference to put things in this order:

  1. The context being verified.
  2. Parameters to index into the context.
  3. output.

The initial change was to pass the recorder by const ref instead of const ptr
(not sure why that was)... then I just "rationalized" the param order at the
same time.
  

[sebsg, 2017/06/21 21:08:03]

SGTM

     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 920 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 576 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 439 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 89 matching lines @@
     base::HistogramTester histogram_tester;
     autofill_manager_->OnTextFieldDidChange(form, form.fields[1], 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 669 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