Refactor UKM interface for mojo-ification

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 16 matching lines @@
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/payments/payments_client.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/popup_item_ids.h"
 #include "components/autofill/core/browser/test_autofill_client.h"
 #include "components/autofill/core/browser/test_autofill_driver.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
-#include "components/metrics/proto/ukm/entry.pb.h"
 #include "components/prefs/pref_service.h"
 #include "components/rappor/test_rappor_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
 #include "components/signin/core/browser/test_signin_client.h"
 #include "components/signin/core/common/signin_pref_names.h"
-#include "components/ukm/test_ukm_service.h"
-#include "components/ukm/ukm_entry.h"
+#include "components/ukm/test_ukm_recorder.h"
 #include "components/ukm/ukm_source.h"
 #include "components/webdata/common/web_data_results.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/rect.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 using base::Bucket;
 using base::TimeTicks;
@@ skipping 247 matching lines @@
         observed_submission);
   }
 
  private:
   bool autofill_enabled_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
-// Finds the specified UKM metric by |name| in the specified UKM |metrics|.
-const ukm::Entry_Metric* FindMetric(
-    const char* name,
-    const google::protobuf::RepeatedPtrField<ukm::Entry_Metric>& metrics) {
-  for (const auto& metric : metrics) {
-    if (metric.metric_hash() == base::HashMetricName(name))
-      return &metric;
-  }
-  return nullptr;
-}
-
 MATCHER(CompareMetrics, "") {
-  const ukm::Entry_Metric& lhs = ::testing::get<0>(arg);
+  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;
+  return lhs->metric_hash == base::HashMetricName(rhs.first) &&
+         lhs->value == rhs.second;
 }
 
 void VerifyDeveloperEngagementUkm(
     const FormData& form,
-    const ukm::TestUkmService* ukm_service,
+    const ukm::TestUkmRecorder* ukm_recorder,
     const std::vector<int64_t>& expected_metric_values) {
-  const ukm::UkmEntry* entry = ukm_service->GetEntryForEntryName(
+  const ukm::mojom::UkmEntry* entry = ukm_recorder->GetEntryForEntryName(
       internal::kUKMDeveloperEngagementEntryName);
   ASSERT_NE(nullptr, entry);
-  ukm::Entry entry_proto;
-  entry->PopulateProto(&entry_proto);
-
   const ukm::UkmSource* source =
-      ukm_service->GetSourceForSourceId(entry_proto.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_proto.metrics(),
+  EXPECT_THAT(entry->metrics,
               UnorderedPointwise(CompareMetrics(), expected_metrics));
 }
 
 MATCHER(CompareMetricsIgnoringMillisecondsSinceFormParsed, "") {
-  const ukm::Entry_Metric& lhs = ::testing::get<0>(arg);
+  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 &&
+  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::TestUkmService* ukm_service,
+    const ukm::TestUkmRecorder* ukm_recorder,
     const char* event_name,
     const std::vector<std::vector<std::pair<const char*, int64_t>>>&
         expected_metrics) {
   size_t expected_metrics_index = 0;
-  for (size_t i = 0; i < ukm_service->entries_count(); ++i) {
-    const ukm::UkmEntry* entry = ukm_service->GetEntry(i);
-    if (entry->event_hash() != base::HashMetricName(event_name))
+  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;
 
-    ukm::Entry entry_proto;
-    entry->PopulateProto(&entry_proto);
-
     const ukm::UkmSource* source =
-        ukm_service->GetSourceForSourceId(entry_proto.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_proto.metrics(),
+        entry->metrics,
         UnorderedPointwise(CompareMetricsIgnoringMillisecondsSinceFormParsed(),
                            expected_metrics[expected_metrics_index++]));
   }
 }
 
 void VerifySubmitFormUkm(const FormData& form,
-                         const ukm::TestUkmService* ukm_service,
+                         const ukm::TestUkmRecorder* ukm_recorder,
                          AutofillMetrics::AutofillFormSubmittedState state) {
   VerifyFormInteractionUkm(
-      form, ukm_service, internal::kUKMFormSubmittedEntryName,
+      form, ukm_recorder, internal::kUKMFormSubmittedEntryName,
       {{{internal::kUKMAutofillFormSubmittedStateMetricName, state},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
 }
 
 }  // namespace
 
 // This is defined in the autofill_metrics.cc implementation file.
 int GetFieldTypeGroupMetric(ServerFieldType field_type,
                             AutofillMetrics::FieldTypeQualityMetric metric);
 
@@ skipping 60 matching lines @@
   // PersonalDataManager to be around when it gets destroyed.
   autofill_manager_.reset();
   autofill_driver_.reset();
   personal_data_.reset();
   signin_manager_->Shutdown();
   signin_manager_.reset();
   account_tracker_->Shutdown();
   account_tracker_.reset();
   signin_client_.reset();
   test::ReenableSystemServices();
-  autofill_client_.GetTestUkmService()->Purge();
+  autofill_client_.GetTestUkmRecorder()->Purge();
 }
 
 void AutofillMetricsTest::EnableWalletSync() {
   signin_manager_->SetAuthenticatedAccountInfo("12345", "syncuser@example.com");
 }
 
 // Test that we log quality metrics appropriately.
 TEST_F(AutofillMetricsTest, QualityMetrics) {
   // Set up our form data.
   FormData form;
@@ skipping 472 matching lines @@
   form.fields.push_back(field);
 
   // No autocomplete attribute. No metric logged.
   test::CreateTestFormField("Address", "address", "", "text", &field);
   field.autocomplete_attribute = "";
   form.fields.push_back(field);
 
   std::unique_ptr<TestFormStructure> form_structure =
       base::MakeUnique<TestFormStructure>(form);
   TestFormStructure* form_structure_ptr = form_structure.get();
-  form_structure->DetermineHeuristicTypes(nullptr /* ukm_service */);
+  form_structure->DetermineHeuristicTypes(nullptr /* ukm_recorder */);
   autofill_manager_->form_structures()->push_back(std::move(form_structure));
 
   AutofillQueryResponseContents response;
   // Server response will match with autocomplete.
   response.add_field()->set_autofill_type(NAME_LAST);
   // Server response will NOT match with autocomplete.
   response.add_field()->set_autofill_type(NAME_FIRST);
   // Server response will have no data.
   response.add_field()->set_autofill_type(NO_SERVER_DATA);
   // Not logged.
@@ skipping 777 matching lines @@
     histogram_tester.ExpectBucketCount(
         "Autofill.DeveloperEngagement",
         AutofillMetrics::FORM_CONTAINS_UPI_VPA_HINT, 1);
   }
 }
 
 // Verify that we correctly log UKM for form parsed without type hints regarding
 // developer engagement.
 TEST_F(AutofillMetricsTest,
        UkmDeveloperEngagement_LogFillableFormParsedWithoutTypeHints) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   // Start with a non-fillable form.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
 
   FormFieldData field;
   test::CreateTestFormField("Name", "name", "", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Email", "email", "", "text", &field);
   form.fields.push_back(field);
 
   std::vector<FormData> forms(1, form);
 
   // Ensure no metrics are logged when loading a non-fillable form.
   {
     autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
-    EXPECT_EQ(0U, ukm_service->sources_count());
-    EXPECT_EQ(0U, ukm_service->entries_count());
+    EXPECT_EQ(0U, ukm_recorder->sources_count());
+    EXPECT_EQ(0U, ukm_recorder->entries_count());
   }
 
   // Add another field to the form, so that it becomes fillable.
   test::CreateTestFormField("Phone", "phone", "", "text", &field);
   forms.back().fields.push_back(field);
 
   // 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, ukm_service->entries_count());
-    ASSERT_EQ(1U, ukm_service->sources_count());
+    ASSERT_EQ(1U, ukm_recorder->entries_count());
+    ASSERT_EQ(1U, ukm_recorder->sources_count());
     VerifyDeveloperEngagementUkm(
-        form, ukm_service,
+        form, ukm_recorder,
         {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) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
 
   FormFieldData field;
   test::CreateTestFormField("Name", "name", "", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Email", "email", "", "text", &field);
@@ skipping 19 matching lines @@
   test::CreateTestFormField("", "", "", "text", &field);
   field.autocomplete_attribute = "address-line1";
   forms.back().fields.push_back(field);
 
   // 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, ukm_service->entries_count());
-    ASSERT_EQ(1U, ukm_service->sources_count());
+    ASSERT_EQ(1U, ukm_recorder->entries_count());
+    ASSERT_EQ(1U, ukm_recorder->sources_count());
     VerifyDeveloperEngagementUkm(
-        form, ukm_service,
+        form, ukm_recorder,
         {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) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
 
   FormFieldData field;
   test::CreateTestFormField("Name", "name", "", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Email", "email", "", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Payment", "payment", "", "text", &field);
   field.autocomplete_attribute = "upi-vpa";
   form.fields.push_back(field);
 
   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, ukm_service->entries_count());
-    ASSERT_EQ(1U, ukm_service->sources_count());
-    VerifyDeveloperEngagementUkm(form, ukm_service,
+    ASSERT_EQ(1U, ukm_recorder->entries_count());
+    ASSERT_EQ(1U, ukm_recorder->sources_count());
+    VerifyDeveloperEngagementUkm(form, ukm_recorder,
                                  {AutofillMetrics::FORM_CONTAINS_UPI_VPA_HINT});
-    ukm_service->Purge();
+    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, ukm_service,
+        form, ukm_recorder,
         {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 164 matching lines @@
     // Simulate activating the autofill popup for the email field after typing.
     form.fields[0].is_autofilled = true;
     base::HistogramTester histogram_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     histogram_tester.ExpectTotalCount("Autofill.AddressSuggestionsCount", 0);
   }
 }
 
 // Test that the credit card checkout flow user actions are correctly logged.
 TEST_F(AutofillMetricsTest, CreditCardCheckoutFlowUserActions) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   personal_data_->RecreateCreditCards(
       true /* include_local_credit_card */,
       false /* include_masked_server_credit_card */,
       false /* include_full_server_credit_card */);
 
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
@@ skipping 58 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, ukm_service, internal::kUKMSuggestionsShownEntryName,
+      form, ukm_recorder, internal::kUKMSuggestionsShownEntryName,
       {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
   // Expect 2 |FORM_EVENT_LOCAL_SUGGESTION_FILLED| events. First, from
   // call to |external_delegate_->DidAcceptSuggestion|. Second, from call to
   // |autofill_manager_->FillOrPreviewForm|.
   VerifyFormInteractionUkm(
-      form, ukm_service, internal::kUKMSuggestionFilledEntryName,
+      form, ukm_recorder, 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, ukm_service,
+  VerifySubmitFormUkm(form, ukm_recorder,
                       AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
 }
 
 // Test that the profile checkout flow user actions are correctly logged.
 TEST_F(AutofillMetricsTest, ProfileCheckoutFlowUserActions) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   // Create a profile.
   personal_data_->RecreateProfile();
 
   // 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 56 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, ukm_service, internal::kUKMSuggestionsShownEntryName,
+      form, ukm_recorder, internal::kUKMSuggestionsShownEntryName,
       {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
   // Expect 2 |FORM_EVENT_LOCAL_SUGGESTION_FILLED| events. First, from
   // call to |external_delegate_->DidAcceptSuggestion|. Second, from call to
   // |autofill_manager_->FillOrPreviewForm|.
   VerifyFormInteractionUkm(
-      form, ukm_service, internal::kUKMSuggestionFilledEntryName,
+      form, ukm_recorder, 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, ukm_service,
+  VerifySubmitFormUkm(form, ukm_recorder,
                       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 536 matching lines @@
                                        std::string());
     histogram_tester.ExpectTotalCount(
         "Autofill.UnmaskPrompt.GetRealPanDuration", 1);
     histogram_tester.ExpectTotalCount(
         "Autofill.UnmaskPrompt.GetRealPanDuration.Failure", 1);
   }
 }
 
 // Test that we log submitted form events for credit cards.
 TEST_F(AutofillMetricsTest, CreditCardSubmittedFormEvents) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   EnableWalletSync();
   // Creating all kinds of cards.
   personal_data_->RecreateCreditCards(
       true /* include_local_credit_card */,
       true /* include_masked_server_credit_card */,
       true /* include_full_server_credit_card */);
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
@@ skipping 21 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, ukm_service,
+    VerifySubmitFormUkm(form, ukm_recorder,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
-  ukm_service->Purge();
+  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, ukm_service, internal::kUKMSuggestionsShownEntryName,
+        form, ukm_recorder, internal::kUKMSuggestionsShownEntryName,
         {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
-    VerifySubmitFormUkm(form, ukm_service,
+    VerifySubmitFormUkm(form, ukm_recorder,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
-  ukm_service->Purge();
+  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, ukm_service, internal::kUKMSuggestionFilledEntryName,
+        form, ukm_recorder, internal::kUKMSuggestionFilledEntryName,
         {{{internal::kUKMRecordTypeMetricName, CreditCard::LOCAL_CARD},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
-    VerifySubmitFormUkm(form, ukm_service,
+    VerifySubmitFormUkm(form, ukm_recorder,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
-  ukm_service->Purge();
+  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, ukm_service, internal::kUKMSuggestionFilledEntryName,
+        form, ukm_recorder, internal::kUKMSuggestionFilledEntryName,
         {{{internal::kUKMRecordTypeMetricName, CreditCard::FULL_SERVER_CARD},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
-    VerifySubmitFormUkm(form, ukm_service,
+    VerifySubmitFormUkm(form, ukm_recorder,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
-  ukm_service->Purge();
+  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, ukm_service, internal::kUKMSuggestionFilledEntryName,
+        form, ukm_recorder, internal::kUKMSuggestionFilledEntryName,
         {{{internal::kUKMRecordTypeMetricName, CreditCard::MASKED_SERVER_CARD},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
     VerifyFormInteractionUkm(
-        form, ukm_service, internal::kUKMSelectedMaskedServerCardEntryName,
+        form, ukm_recorder, internal::kUKMSelectedMaskedServerCardEntryName,
         {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
-    VerifySubmitFormUkm(form, ukm_service,
+    VerifySubmitFormUkm(form, ukm_recorder,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
-  ukm_service->Purge();
+  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, ukm_service, internal::kUKMFormSubmittedEntryName,
+        form, ukm_recorder, internal::kUKMFormSubmittedEntryName,
         {{{internal::kUKMAutofillFormSubmittedStateMetricName,
            AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA},
           {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
 
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
 
     VerifyFormInteractionUkm(
-        form, ukm_service, internal::kUKMFormSubmittedEntryName,
+        form, ukm_recorder, 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 25 matching lines @@
         AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_SUBMITTED_ONCE, 0);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::
             FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_SUBMITTED_ONCE,
         0);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
-  ukm_service->Purge();
+  ukm_recorder->Purge();
 
   autofill_manager_->AddSeenForm(form, field_types, field_types);
 
   {
     // Simulating submission with suggestion shown but without previous
     // interaction.
     base::HistogramTester histogram_tester;
     autofill_manager_->DidShowSuggestions(true /* is_new_popup */, form, field);
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
     histogram_tester.ExpectBucketCount(
@@ skipping 25 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, ukm_service, internal::kUKMSuggestionsShownEntryName,
+        form, ukm_recorder, internal::kUKMSuggestionsShownEntryName,
         {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
-    VerifySubmitFormUkm(form, ukm_service,
+    VerifySubmitFormUkm(form, ukm_recorder,
                         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 402 matching lines @@
         "Autofill.FormEvents.Address",
         AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED, 2);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.Address",
         AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED_ONCE, 1);
   }
 }
 
 // Test that we log submitted form events for address.
 TEST_F(AutofillMetricsTest, AddressSubmittedFormEvents) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   EnableWalletSync();
   // Create a profile.
   personal_data_->RecreateProfile();
   // 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 18 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, ukm_service,
+    VerifySubmitFormUkm(form, ukm_recorder,
                         AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
   }
 
   // Reset the autofill manager state and purge UKM logs.
   autofill_manager_->Reset();
-  ukm_service->Purge();
+  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(
@@ skipping 474 matching lines @@
   base::HistogramTester histogram_tester;
   AutofillProfile profile;
   profile.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(13));
   profile.RecordAndLogUse();
   histogram_tester.ExpectBucketCount("Autofill.DaysSinceLastUse.Profile", 13,
                                      1);
 }
 
 // Verify that we correctly log the submitted form's state.
 TEST_F(AutofillMetricsTest, AutofillFormSubmittedState) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   // Start with a form with insufficiently many fields.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
 
   FormFieldData field;
   test::CreateTestFormField("Name", "name", "", "text", &field);
   form.fields.push_back(field);
@@ skipping 24 matching lines @@
     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, ukm_service->entries_count());
-    ASSERT_EQ(2U, ukm_service->sources_count());
+    ASSERT_EQ(2U, ukm_recorder->entries_count());
+    ASSERT_EQ(2U, ukm_recorder->sources_count());
     VerifyDeveloperEngagementUkm(
-        form, ukm_service,
+        form, ukm_recorder,
         {AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS});
-    VerifyFormInteractionUkm(form, ukm_service,
+    VerifyFormInteractionUkm(form, ukm_recorder,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_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, ukm_service,
+    VerifyFormInteractionUkm(form, ukm_recorder,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_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, ukm_service,
+    VerifyFormInteractionUkm(form, ukm_recorder,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_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, ukm_service, internal::kUKMSuggestionsShownEntryName,
+        form, ukm_recorder, internal::kUKMSuggestionsShownEntryName,
         {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
     expected_form_submission_ukm_metrics.push_back(
         {{internal::kUKMAutofillFormSubmittedStateMetricName,
           AutofillMetrics::FILLABLE_FORM_AUTOFILLED_NONE_DID_SHOW_SUGGESTIONS},
          {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}});
-    VerifyFormInteractionUkm(form, ukm_service,
+    VerifyFormInteractionUkm(form, ukm_recorder,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_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, ukm_service,
+    VerifyFormInteractionUkm(form, ukm_recorder,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_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, ukm_service,
+    VerifyFormInteractionUkm(form, ukm_recorder,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_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, ukm_service,
+    VerifyFormInteractionUkm(form, ukm_recorder,
                              internal::kUKMFormSubmittedEntryName,
                              expected_form_submission_ukm_metrics);
   }
 }
 
 // Verify that we correctly log user happiness metrics dealing with form
 // interaction.
 TEST_F(AutofillMetricsTest, UserHappinessFormInteraction) {
-  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
   // Load a fillable form.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
 
   FormFieldData field;
   test::CreateTestFormField("Name", "name", "", "text", &field);
   form.fields.push_back(field);
@@ skipping 84 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, ukm_service, internal::kUKMInteractedWithFormEntryName,
+      form, ukm_recorder, internal::kUKMInteractedWithFormEntryName,
       {{{internal::kUKMIsForCreditCardMetricName, false},
         {internal::kUKMLocalRecordTypeCountMetricName, 0},
         {internal::kUKMServerRecordTypeCountMetricName, 0}}});
   VerifyFormInteractionUkm(
-      form, ukm_service, internal::kUKMSuggestionsShownEntryName,
+      form, ukm_recorder, internal::kUKMSuggestionsShownEntryName,
       {{{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}},
        {{internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
   VerifyFormInteractionUkm(
-      form, ukm_service, internal::kUKMSuggestionFilledEntryName,
+      form, ukm_recorder, internal::kUKMSuggestionFilledEntryName,
       {{{internal::kUKMRecordTypeMetricName, AutofillProfile::LOCAL_PROFILE},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}},
        {{internal::kUKMRecordTypeMetricName, AutofillProfile::LOCAL_PROFILE},
         {internal::kUKMMillisecondsSinceFormParsedMetricName, 0}}});
   VerifyFormInteractionUkm(
-      form, ukm_service, internal::kUKMTextFieldDidChangeEntryName,
+      form, ukm_recorder, 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 577 matching lines @@
     // Check that the nonsecure histogram was not recorded. ExpectBucketCount()
     // can't be used here because it expects the histogram to exist.
     EXPECT_EQ(
         0, histograms.GetTotalCountsForPrefix("Autofill.FormEvents.CreditCard")
                ["Autofill.FormEvents.CreditCard.OnNonsecurePage"]);
   }
 }
 
 // Tests that logging CardUploadDecision UKM works as expected.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric) {
-  ukm::UkmServiceTestingHarness ukm_service_test_harness;
+  ukm::TestUkmRecorder test_ukm_recorder;
   GURL url("https://www.google.com");
   int upload_decision = 1;
   std::vector<std::pair<const char*, int>> metrics = {
       {internal::kUKMCardUploadDecisionMetricName, upload_decision}};
 
-  EXPECT_TRUE(AutofillMetrics::LogUkm(
-      ukm_service_test_harness.test_ukm_service(), url,
-      internal::kUKMCardUploadDecisionEntryName, metrics));
+  EXPECT_TRUE(AutofillMetrics::LogUkm(&test_ukm_recorder, url,
+                                      internal::kUKMCardUploadDecisionEntryName,
+                                      metrics));
 
   // Make sure that the UKM was logged correctly.
-  ukm::TestUkmService* ukm_service =
-      ukm_service_test_harness.test_ukm_service();
+  ukm::TestUkmRecorder* ukm_recorder = &test_ukm_recorder;
 
-  ASSERT_EQ(1U, ukm_service->sources_count());
+  ASSERT_EQ(1U, ukm_recorder->sources_count());
   const ukm::UkmSource* source =
-      ukm_service->GetSourceForUrl(url.spec().c_str());
+      ukm_recorder->GetSourceForUrl(url.spec().c_str());
   EXPECT_EQ(url.spec(), source->url().spec());
 
-  ASSERT_EQ(1U, ukm_service->entries_count());
-  const ukm::UkmEntry* entry = ukm_service->GetEntry(0);
-  EXPECT_EQ(source->id(), entry->source_id());
+  ASSERT_EQ(1U, ukm_recorder->entries_count());
+  const ukm::mojom::UkmEntry* entry = ukm_recorder->GetEntry(0);
 
   // Make sure that a card upload decision entry was logged.
-  ukm::Entry entry_proto;
-  entry->PopulateProto(&entry_proto);
-  EXPECT_EQ(source->id(), entry_proto.source_id());
+  EXPECT_EQ(source->id(), entry->source_id);
   EXPECT_EQ(base::HashMetricName(internal::kUKMCardUploadDecisionEntryName),
-            entry_proto.event_hash());
-  EXPECT_EQ(1, entry_proto.metrics_size());
+            entry->event_hash);
+  EXPECT_EQ(1U, entry->metrics.size());
 
   // Make sure that the correct upload decision was logged.
-  const ukm::Entry_Metric* metric = FindMetric(
-      internal::kUKMCardUploadDecisionMetricName, entry_proto.metrics());
+  const ukm::mojom::UkmMetric* metric = ukm::TestUkmRecorder::FindMetric(
+      entry, internal::kUKMCardUploadDecisionMetricName);
   ASSERT_NE(nullptr, metric);
-  EXPECT_EQ(upload_decision, metric->value());
+  EXPECT_EQ(upload_decision, metric->value);
 }
 
 // Tests that logging DeveloperEngagement UKM works as expected.
 TEST_F(AutofillMetricsTest, RecordDeveloperEngagementMetric) {
-  ukm::UkmServiceTestingHarness ukm_service_test_harness;
+  ukm::TestUkmRecorder test_ukm_recorder;
   GURL url("https://www.google.com");
   int form_structure_metric = 1;
   std::vector<std::pair<const char*, int>> metrics = {
       {internal::kUKMDeveloperEngagementMetricName, form_structure_metric}};
 
   EXPECT_TRUE(AutofillMetrics::LogUkm(
-      ukm_service_test_harness.test_ukm_service(), url,
-      internal::kUKMDeveloperEngagementEntryName, metrics));
+      &test_ukm_recorder, url, internal::kUKMDeveloperEngagementEntryName,
+      metrics));
 
   // Make sure that the UKM was logged correctly.
-  ukm::TestUkmService* ukm_service =
-      ukm_service_test_harness.test_ukm_service();
+  ukm::TestUkmRecorder* ukm_recorder = &test_ukm_recorder;
 
-  ASSERT_EQ(1U, ukm_service->sources_count());
+  ASSERT_EQ(1U, ukm_recorder->sources_count());
   const ukm::UkmSource* source =
-      ukm_service->GetSourceForUrl(url.spec().c_str());
+      ukm_recorder->GetSourceForUrl(url.spec().c_str());
   EXPECT_EQ(url.spec(), source->url().spec());
 
-  ASSERT_EQ(1U, ukm_service->entries_count());
-  const ukm::UkmEntry* entry = ukm_service->GetEntry(0);
-  EXPECT_EQ(source->id(), entry->source_id());
+  ASSERT_EQ(1U, ukm_recorder->entries_count());
+  const ukm::mojom::UkmEntry* entry = ukm_recorder->GetEntry(0);
 
   // Make sure that a developer engagement entry was logged.
-  ukm::Entry entry_proto;
-  entry->PopulateProto(&entry_proto);
-  EXPECT_EQ(source->id(), entry_proto.source_id());
+  EXPECT_EQ(source->id(), entry->source_id);
   EXPECT_EQ(base::HashMetricName(internal::kUKMDeveloperEngagementEntryName),
-            entry_proto.event_hash());
-  EXPECT_EQ(1, entry_proto.metrics_size());
+            entry->event_hash);
+  EXPECT_EQ(1U, entry->metrics.size());
 
   // Make sure that the correct developer engagement metric was logged.
-  const ukm::Entry_Metric* metric = FindMetric(
-      internal::kUKMDeveloperEngagementMetricName, entry_proto.metrics());
+  const ukm::mojom::UkmMetric* metric = ukm::TestUkmRecorder::FindMetric(
+      entry, internal::kUKMDeveloperEngagementMetricName);
   ASSERT_NE(nullptr, metric);
-  EXPECT_EQ(form_structure_metric, metric->value());
+  EXPECT_EQ(form_structure_metric, metric->value);
 }
 
 // Tests that no UKM is logged when the URL is not valid.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_InvalidUrl) {
-  ukm::UkmServiceTestingHarness ukm_service_test_harness;
+  ukm::TestUkmRecorder test_ukm_recorder;
   GURL url("");
   std::vector<std::pair<const char*, int>> metrics = {{"metric", 1}};
 
-  EXPECT_FALSE(AutofillMetrics::LogUkm(
-      ukm_service_test_harness.test_ukm_service(), url, "test_ukm", metrics));
-  EXPECT_EQ(0U, ukm_service_test_harness.test_ukm_service()->sources_count());
+  EXPECT_FALSE(
+      AutofillMetrics::LogUkm(&test_ukm_recorder, url, "test_ukm", metrics));
+  EXPECT_EQ(0U, test_ukm_recorder.sources_count());
 }
 
 // Tests that no UKM is logged when the metrics map is empty.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_NoMetrics) {
-  ukm::UkmServiceTestingHarness ukm_service_test_harness;
+  ukm::TestUkmRecorder test_ukm_recorder;
   GURL url("https://www.google.com");
   std::vector<std::pair<const char*, int>> metrics;
 
-  EXPECT_FALSE(AutofillMetrics::LogUkm(
-      ukm_service_test_harness.test_ukm_service(), url, "test_ukm", metrics));
-  EXPECT_EQ(0U, ukm_service_test_harness.test_ukm_service()->sources_count());
+  EXPECT_FALSE(
+      AutofillMetrics::LogUkm(&test_ukm_recorder, url, "test_ukm", metrics));
+  EXPECT_EQ(0U, test_ukm_recorder.sources_count());
 }
 
 // Tests that no UKM is logged when the ukm service is null.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_NoUkmService) {
-  ukm::UkmServiceTestingHarness ukm_service_test_harness;
+  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, ukm_service_test_harness.test_ukm_service()->sources_count());
+  ASSERT_EQ(0U, test_ukm_recorder.sources_count());
 }
 
 }  // namespace autofill