UKM that threads together multiple form interaction events.

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>
 #include <vector>
 
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/metrics_hashes.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
@@ skipping 27 matching lines @@
 #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;
 using rappor::TestRapporServiceImpl;
 using ::testing::ElementsAre;
-using ::testing::UnorderedElementsAre;
+using ::testing::Matcher;
+using ::testing::Pointwise;
 
 namespace autofill {
 namespace {
 
 class TestPersonalDataManager : public PersonalDataManager {
  public:
   TestPersonalDataManager()
       : PersonalDataManager("en-US"),
         autofill_enabled_(true) {
     CreateTestAutofillProfiles(&web_profiles_);
@@ skipping 189 matching lines @@
                    const std::vector<ServerFieldType>& server_types) {
     FormData empty_form = form;
     for (size_t i = 0; i < empty_form.fields.size(); ++i) {
       empty_form.fields[i].value = base::string16();
     }
 
     std::unique_ptr<TestFormStructure> form_structure =
         base::MakeUnique<TestFormStructure>(empty_form);
     form_structure->SetFieldTypes(heuristic_types, server_types);
     form_structures()->push_back(std::move(form_structure));
+
+    form_interactions_ukm_logger()->set_url(form.origin);
+    form_interactions_ukm_logger()->set_form_loaded_timestamp(TimeTicks::Now());
   }
 
   // Calls AutofillManager::OnWillSubmitForm and waits for it to complete.
   void WillSubmitForm(const FormData& form, const TimeTicks& timestamp) {
     ResetRunLoop();
     if (!OnWillSubmitForm(form, timestamp))
       return;
 
     // Wait for the asynchronous OnWillSubmitForm() call to complete.
     RunRunLoop();
   }
 
   // Calls both AutofillManager::OnWillSubmitForm and
   // AutofillManager::OnFormSubmitted.
   void SubmitForm(const FormData& form, const TimeTicks& timestamp) {
     WillSubmitForm(form, timestamp);
     OnFormSubmitted(form);
   }
 
   // Control the run loop from within tests.
   void ResetRunLoop() { run_loop_.reset(new base::RunLoop()); }
   void RunRunLoop() { run_loop_->Run(); }
 
   void UploadFormDataAsyncCallback(const FormStructure* submitted_form,
-                                   const base::TimeTicks& load_time,
-                                   const base::TimeTicks& interaction_time,
-                                   const base::TimeTicks& submission_time,
+                                   const TimeTicks& load_time,
+                                   const TimeTicks& interaction_time,
+                                   const TimeTicks& submission_time,
                                    bool observed_submission) override {
     run_loop_->Quit();
 
     AutofillManager::UploadFormDataAsyncCallback(
         submitted_form, load_time, interaction_time, submission_time,
         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 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 FormData& form,
+    const ukm::TestUkmService* ukm_service,
+    const std::vector<int64_t>& expected_metric_values) {
+  const ukm::UkmEntry* entry = ukm_service->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());
+  ASSERT_NE(nullptr, source);
+  EXPECT_EQ(form.origin, source->url());
+
+  std::vector<std::pair<const char*, int64_t>> expected_metrics;
+  for (const auto it : expected_metric_values)
+    expected_metrics.push_back(
+        {internal::kUKMDeveloperEngagementMetricName, it});
+
+  EXPECT_THAT(entry_proto.metrics(),
+              Pointwise(CompareMetrics(), expected_metrics));
+}
+
+void VerifyFormInteractionsUkm(
+    const FormData& form,
+    const ukm::TestUkmService* ukm_service,
+    const std::vector<std::pair<const char*, int64_t>>& expected_events) {
+  int entry_num = 0;
+  // Skip |DeveloperEngagement| entries.
+  ASSERT_GT(ukm_service->entries_count(), static_cast<size_t>(0));
+  while (ukm_service->GetEntry(entry_num)->event_hash() ==
+         base::HashMetricName(internal::kUKMDeveloperEngagementEntryName))
+    entry_num++;
+
+  for (const auto& it : expected_events) {
+    const ukm::UkmEntry* entry = ukm_service->GetEntry(entry_num++);
+    ASSERT_NE(nullptr, entry);
+    ukm::Entry entry_proto;
+    entry->PopulateProto(&entry_proto);
+
+    const ukm::UkmSource* source =
+        ukm_service->GetSourceForSourceId(entry_proto.source_id());
+    ASSERT_NE(nullptr, source);
+    EXPECT_EQ(form.origin, source->url());
+
+    ASSERT_EQ(2, entry_proto.metrics().size());
+    EXPECT_EQ(base::HashMetricName(it.first),
+              entry_proto.metrics().Get(0).metric_hash());
+    EXPECT_EQ(it.second, entry_proto.metrics().Get(0).value());
+
+    EXPECT_EQ(base::HashMetricName(
+                  internal::kUKMMillisecondsSinceFormLoadedMetricName),
+              entry_proto.metrics().Get(1).metric_hash());
+  }
+}
+
+void VerifyUniqueFormInteractionEventUkm(const FormData& form,
+                                         const ukm::TestUkmService* ukm_service,
+                                         const char* event_name,
+                                         int expected_metric_value) {
+  const ukm::UkmEntry* entry = ukm_service->GetEntryForEntryName(event_name);
+  ASSERT_NE(nullptr, entry);
+  ukm::Entry entry_proto;
+  entry->PopulateProto(&entry_proto);
+
+  const ukm::UkmSource* source =
+      ukm_service->GetSourceForSourceId(entry_proto.source_id());
+  ASSERT_NE(nullptr, source);
+  EXPECT_EQ(form.origin, source->url());
+
+  ASSERT_EQ(2, entry_proto.metrics().size());
+  EXPECT_EQ(base::HashMetricName(event_name),
+            entry_proto.metrics().Get(0).metric_hash());
+  EXPECT_EQ(expected_metric_value, entry_proto.metrics().Get(0).value());
+
+  EXPECT_EQ(
+      base::HashMetricName(internal::kUKMMillisecondsSinceFormLoadedMetricName),
+      entry_proto.metrics().Get(1).metric_hash());
+}
+
 }  // 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 57 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();
 }
 
 void AutofillMetricsTest::EnableWalletSync() {
   signin_manager_->SetAuthenticatedAccountInfo("12345", "syncuser@example.com");
 }
 
 void AutofillMetricsTest::EnableUkmLogging() {
   scoped_feature_list_.InitAndEnableFeature(kAutofillUkmLogging);
 }
 
@@ skipping 157 matching lines @@
   field.is_autofilled = false;
   form.fields.push_back(field);
 
   test::CreateTestFormField("Phone", "phone", "2345678901", "tel", &field);
   field.is_autofilled = false;
   form.fields.push_back(field);
 
   // Simulate a OnFormsSeen() call that should trigger the recording.
   std::vector<FormData> forms;
   forms.push_back(form);
-  autofill_manager_->OnFormsSeen(forms, base::TimeTicks::Now());
+  autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
 
   // Because these metrics are related to timing, it is not possible to know in
   // advance which bucket the sample will fall into, so we just need to make
   // sure we have valid samples.
   EXPECT_FALSE(
       histogram_tester.GetAllSamples("Autofill.Timing.DetermineHeuristicTypes")
           .empty());
   EXPECT_FALSE(
       histogram_tester.GetAllSamples("Autofill.Timing.ParseForm").empty());
 }
@@ skipping 789 matching lines @@
   autofill_manager_->OnTextFieldDidChange(form, form.fields[0], TimeTicks());
   autofill_manager_->OnTextFieldDidChange(form, form.fields[1], TimeTicks());
 
   // Simulate form submission.
   autofill_manager_->SubmitForm(form, TimeTicks::Now());
 
   // An autofillable form was submitted, and the number of edited autofilled
   // fields is logged.
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfEditedAutofilledFieldsAtSubmission", 2, 1);
+
+  // UKM must not be logged unless enabled.
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  EXPECT_EQ(0U, ukm_service->sources_count());
+  EXPECT_EQ(0U, ukm_service->entries_count());
 }
 
 // Verify that when resetting the autofill manager (such as during a
 // navigation), the proper number of edited fields is logged.
 TEST_F(AutofillMetricsTest, NumberOfEditedAutofilledFields_NoSubmission) {
   // Construct 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");
@@ skipping 156 matching lines @@
   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());
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
     EXPECT_EQ(0U, ukm_service->sources_count());
     EXPECT_EQ(0U, ukm_service->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 to be logged.
+  // Expect the "form parsed without field type hints" metric and the
+  // "form loaded" form interaction event to be logged.
   {
-    autofill_manager_->OnFormsSeen(forms, TimeTicks());
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
-    ASSERT_EQ(1U, ukm_service->sources_count());
-    const ukm::UkmSource* source =
-        ukm_service->GetSourceForUrl(form.origin.spec().c_str());
-    ASSERT_NE(nullptr, source);
-
-    ASSERT_EQ(1U, ukm_service->entries_count());
-    const ukm::UkmEntry* entry = ukm_service->GetEntry(0);
-    EXPECT_EQ(source->id(), entry->source_id());
-
-    ukm::Entry entry_proto;
-    entry->PopulateProto(&entry_proto);
-    EXPECT_EQ(source->id(), entry_proto.source_id());
-    EXPECT_EQ(base::HashMetricName(internal::kUKMDeveloperEngagementEntryName),
-              entry_proto.event_hash());
-    const ukm::Entry_Metric* metric = FindMetric(
-        internal::kUKMDeveloperEngagementMetricName, entry_proto.metrics());
-    ASSERT_NE(nullptr, metric);
-    EXPECT_EQ(AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS,
-              metric->value());
+    // Expect an entry for |kUKMDeveloperEngagementEntryName| and another entry
+    // for |kUKMUserHappinessMetricName|. Both entries are for the same URL.
+    ASSERT_EQ(2U, ukm_service->entries_count());
+    ASSERT_EQ(2U, ukm_service->sources_count());
+    VerifyDeveloperEngagementUkm(
+        form, ukm_service,
+        {AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS});
+    VerifyUniqueFormInteractionEventUkm(form, ukm_service,
+                                        internal::kUKMUserHappinessMetricName,
+                                        AutofillMetrics::FORMS_LOADED);
   }
 }
 
 // Verify that we correctly log UKM for form parsed with type hints regarding
 // developer engagement.
 TEST_F(AutofillMetricsTest,
        UkmDeveloperEngagement_LogFillableFormParsedWithTypeHints) {
   EnableUkmLogging();
   ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
 
@@ skipping 22 matching lines @@
   test::CreateTestFormField("", "", "", "text", &field);
   field.autocomplete_attribute = "given-name";
   forms.back().fields.push_back(field);
   test::CreateTestFormField("", "", "", "text", &field);
   field.autocomplete_attribute = "email";
   forms.back().fields.push_back(field);
   test::CreateTestFormField("", "", "", "text", &field);
   field.autocomplete_attribute = "address-line1";
   forms.back().fields.push_back(field);
 
-  // Expect the "form parsed with field type hints" metric to be logged.
+  // Expect the "form parsed without field type hints" metric and the
+  // "form loaded" form interaction event to be logged.
   {
-    autofill_manager_->OnFormsSeen(forms, TimeTicks());
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
-    ASSERT_EQ(1U, ukm_service->sources_count());
-    const ukm::UkmSource* source =
-        ukm_service->GetSourceForUrl(form.origin.spec().c_str());
-    ASSERT_NE(nullptr, source);
-
-    ASSERT_EQ(1U, ukm_service->entries_count());
-    const ukm::UkmEntry* entry = ukm_service->GetEntry(0);
-    EXPECT_EQ(source->id(), entry->source_id());
-
-    ukm::Entry entry_proto;
-    entry->PopulateProto(&entry_proto);
-    EXPECT_EQ(source->id(), entry_proto.source_id());
-    EXPECT_EQ(base::HashMetricName(internal::kUKMDeveloperEngagementEntryName),
-              entry_proto.event_hash());
-    const ukm::Entry_Metric* metric = FindMetric(
-        internal::kUKMDeveloperEngagementMetricName, entry_proto.metrics());
-    ASSERT_NE(nullptr, metric);
-    EXPECT_EQ(AutofillMetrics::FILLABLE_FORM_PARSED_WITH_TYPE_HINTS,
-              metric->value());
+    // Expect an entry for |kUKMDeveloperEngagementEntryName| and another entry
+    // for |kUKMUserHappinessMetricName|. Both entries are for the same URL.
+    ASSERT_EQ(2U, ukm_service->entries_count());
+    ASSERT_EQ(2U, ukm_service->sources_count());
+    VerifyDeveloperEngagementUkm(
+        form, ukm_service,
+        {AutofillMetrics::FILLABLE_FORM_PARSED_WITH_TYPE_HINTS});
+    VerifyUniqueFormInteractionEventUkm(form, ukm_service,
+                                        internal::kUKMUserHappinessMetricName,
+                                        AutofillMetrics::FORMS_LOADED);
   }
 }
 
 // Verify that we correctly log UKM for form parsed with type hints regarding
 // developer engagement.
 TEST_F(AutofillMetricsTest, UkmDeveloperEngagement_LogUpiVpaTypeHint) {
   EnableUkmLogging();
   ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
 
   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.
+  // Expect the "upi-vpa hint" metric to be logged and the "form loaded" form
+  // interaction event to be logged.
   {
-    autofill_manager_->OnFormsSeen(forms, TimeTicks());
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     autofill_manager_->Reset();
 
-    ASSERT_EQ(1U, ukm_service->sources_count());
-    const ukm::UkmSource* source =
-        ukm_service->GetSourceForUrl(form.origin.spec().c_str());
-    ASSERT_NE(nullptr, source);
+    ASSERT_EQ(2U, ukm_service->entries_count());
+    ASSERT_EQ(2U, ukm_service->sources_count());
+    VerifyDeveloperEngagementUkm(form, ukm_service,
+                                 {AutofillMetrics::FORM_CONTAINS_UPI_VPA_HINT});
+    VerifyUniqueFormInteractionEventUkm(form, ukm_service,
+                                        internal::kUKMUserHappinessMetricName,
+                                        AutofillMetrics::FORMS_LOADED);
 
-    ASSERT_EQ(1U, ukm_service->entries_count());
-    const ukm::UkmEntry* entry = ukm_service->GetEntry(0);
-    EXPECT_EQ(source->id(), entry->source_id());
+    ukm_service->Purge();
+  }
 
-    ukm::Entry entry_proto;
-    entry->PopulateProto(&entry_proto);
-    EXPECT_EQ(source->id(), entry_proto.source_id());
-    EXPECT_EQ(base::HashMetricName(internal::kUKMDeveloperEngagementEntryName),
-              entry_proto.event_hash());
-    const ukm::Entry_Metric* metric = FindMetric(
-        internal::kUKMDeveloperEngagementMetricName, entry_proto.metrics());
-    ASSERT_NE(nullptr, metric);
-    EXPECT_EQ(AutofillMetrics::FORM_CONTAINS_UPI_VPA_HINT, metric->value());
+  // 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,
+        {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;
     personal_data_->LoadProfiles();
     histogram_tester.ExpectUniqueSample("Autofill.StoredProfileCount", 2, 1);
@@ skipping 162 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) {
+  EnableUkmLogging();
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+
   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");
   form.action = GURL("http://example.com/submit.html");
@@ skipping 55 matching lines @@
   // Simulate submitting the credit card form.
   {
     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"));
   }
+
+  // Expect 2 |FORM_EVENT_LOCAL_SUGGESTION_FILLED| events. First, from
+  // call to |external_delegate_->DidAcceptSuggestion|. Second, from call to
+  // |autofill_manager_->FillOrPreviewForm|.
+  // Expect |NON_FILLABLE_FORM_OR_NEW_DATA| in |AutofillFormSubmittedState|
+  // because |field.value| is empty in |DeterminePossibleFieldTypesForUpload|.
+  ASSERT_EQ(4U, ukm_service->entries_count());
+  ASSERT_EQ(1U, ukm_service->sources_count());
+  VerifyFormInteractionsUkm(
+      form, ukm_service,
+      {{internal::kUKMCreditCardFormEventName,
+        AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN},
+       {internal::kUKMCreditCardFormEventName,
+        AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED},
+       {internal::kUKMCreditCardFormEventName,
+        AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED},
+       {internal::kUKMAutofillFormSubmittedStateName,
+        AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
 }
 
 // Test that the profile checkout flow user actions are correctly logged.
 TEST_F(AutofillMetricsTest, ProfileCheckoutFlowUserActions) {
+  EnableUkmLogging();
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+
   // 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");
 
   FormFieldData field;
@@ skipping 27 matching lines @@
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_ShowedProfileSuggestions"));
   }
 
   // Simulate selecting a profile suggestions.
   {
     base::UserActionTester user_action_tester;
     std::string guid("00000000-0000-0000-0000-000000000001");  // local profile.
     external_delegate_->DidAcceptSuggestion(
         ASCIIToUTF16("Test"),
-        autofill_manager_->MakeFrontendID(guid, std::string()), 0);
+        autofill_manager_->MakeFrontendID(std::string(), guid), 0);
     EXPECT_EQ(1,
               user_action_tester.GetActionCount("Autofill_SelectedSuggestion"));
   }
 
   // Simulate filling a profile suggestion.
   {
     base::UserActionTester user_action_tester;
     std::string guid("00000000-0000-0000-0000-000000000001");  // local profile.
     autofill_manager_->FillOrPreviewForm(
         AutofillDriver::FORM_DATA_ACTION_FILL, 0, form, form.fields.front(),
         autofill_manager_->MakeFrontendID(std::string(), guid));
     EXPECT_EQ(1, user_action_tester.GetActionCount(
                      "Autofill_FilledProfileSuggestion"));
   }
 
   // Simulate submitting the profile form.
   {
     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"));
   }
+
+  // Expect 2 |FORM_EVENT_LOCAL_SUGGESTION_FILLED| events. First, from
+  // call to |external_delegate_->DidAcceptSuggestion|. Second, from call to
+  // |autofill_manager_->FillOrPreviewForm|.
+  // Expect |NON_FILLABLE_FORM_OR_NEW_DATA| in |AutofillFormSubmittedState|
+  // because |field.value| is empty in |DeterminePossibleFieldTypesForUpload|.
+  VerifyFormInteractionsUkm(
+      form, ukm_service,
+      {{internal::kUKMAddressFormEventName,
+        AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN},
+       {internal::kUKMAddressFormEventName,
+        AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED},
+       {internal::kUKMAddressFormEventName,
+        AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED},
+       {internal::kUKMAutofillFormSubmittedStateName,
+        AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+  ASSERT_EQ(4U, ukm_service->entries_count());
+  ASSERT_EQ(1U, ukm_service->sources_count());
 }
 
 // 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 269 matching lines @@
     base::HistogramTester histogram_tester;
     autofill_manager_->DidShowSuggestions(false /* is_new_popup */, form,
                                           field);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN, 0);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN_ONCE, 0);
   }
+
+  // UKM must not be logged unless enabled.
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+  EXPECT_EQ(0U, ukm_service->sources_count());
+  EXPECT_EQ(0U, ukm_service->entries_count());
 }
 
 // Test that we log selected form event for credit cards.
 TEST_F(AutofillMetricsTest, CreditCardSelectedFormEvents) {
   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 */);
@@ skipping 245 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) {
+  EnableUkmLogging();
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+
   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");
   form.origin = GURL("http://example.com/form.html");
@@ skipping 19 matching lines @@
     // Simulating submission with no filled data.
     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);
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 
   // Reset the autofill manager state.
   autofill_manager_->Reset();
   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);
+
+    ASSERT_EQ(2U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMCreditCardFormEventName,
+          AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN},
+         {internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 
   // Reset the autofill manager state.
   autofill_manager_->Reset();
   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);
+
+    ASSERT_EQ(2U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMCreditCardFormEventName,
+          AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED},
+         {internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 
   // Reset the autofill manager state.
   autofill_manager_->Reset();
   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);
+
+    ASSERT_EQ(2U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMCreditCardFormEventName,
+          AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED},
+         {internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 
   // Reset the autofill manager state.
   autofill_manager_->Reset();
   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);
+
+    ASSERT_EQ(4U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMUnmaskPromptEventName,
+          AutofillMetrics::UNMASK_PROMPT_SHOWN},
+         {internal::kUKMCreditCardFormEventName,
+          AutofillMetrics::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_SELECTED},
+         {internal::kUKMCreditCardFormEventName,
+          AutofillMetrics::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_FILLED},
+         {internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 
+  // Reset the autofill manager state.
+  autofill_manager_->Reset();
+
   // 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());
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
+
+    autofill_manager_->form_interactions_ukm_logger()
+        ->set_form_loaded_timestamp(TimeTicks::Now());
     autofill_manager_->SubmitForm(form, TimeTicks::Now());
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
+
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_NO_SUGGESTION_WILL_SUBMIT_ONCE, 1);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_SUGGESTION_SHOWN_WILL_SUBMIT_ONCE, 0);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_WILL_SUBMIT_ONCE, 0);
     histogram_tester.ExpectBucketCount(
@@ skipping 60 matching lines @@
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_WILL_SUBMIT_ONCE, 0);
     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);
+
+    ASSERT_EQ(2U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMCreditCardFormEventName,
+          AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN},
+         {internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 }
 
 // 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.
   personal_data_->RecreateCreditCards(
@@ skipping 401 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) {
+  EnableUkmLogging();
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+
   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");
 
   FormFieldData field;
@@ skipping 16 matching lines @@
     // Simulating submission with no filled data.
     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);
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 
   // Reset the autofill manager state.
   autofill_manager_->Reset();
   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);
@@ skipping 30 matching lines @@
 
   // 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());
+
+    autofill_manager_->form_interactions_ukm_logger()
+        ->set_form_loaded_timestamp(TimeTicks::Now());
     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_SUGGESTION_SHOWN_WILL_SUBMIT_ONCE, 0);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.Address",
         AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_WILL_SUBMIT_ONCE, 0);
     histogram_tester.ExpectBucketCount(
@@ skipping 16 matching lines @@
   // Reset the autofill manager state.
   autofill_manager_->Reset();
   autofill_manager_->AddSeenForm(form, field_types, field_types);
 
   {
     // Simulating submission with suggestion show 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(
         "Autofill.FormEvents.Address",
         AutofillMetrics::FORM_EVENT_SUGGESTION_SHOWN_WILL_SUBMIT_ONCE, 0);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.Address",
         AutofillMetrics::FORM_EVENT_NO_SUGGESTION_WILL_SUBMIT_ONCE, 0);
     histogram_tester.ExpectBucketCount(
         "Autofill.FormEvents.Address",
         AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_WILL_SUBMIT_ONCE, 0);
     histogram_tester.ExpectBucketCount(
@@ skipping 350 matching lines @@
   {
     // Simulate activating the autofill popup for the street field.
     base::HistogramTester histogram_tester;
     autofill_manager_->OnQueryFormFieldAutofill(0, form, field, gfx::RectF());
     histogram_tester.ExpectUniqueSample(
         "Autofill.FormEvents.Address.WithOnlyLocalData",
         AutofillMetrics::FORM_EVENT_INTERACTED_ONCE, 1);
   }
 }
 
-
 // Test that we log that Autofill is enabled when filling a form.
 TEST_F(AutofillMetricsTest, AutofillIsEnabledAtPageLoad) {
   base::HistogramTester histogram_tester;
   autofill_manager_->set_autofill_enabled(true);
   autofill_manager_->OnFormsSeen(std::vector<FormData>(), TimeTicks());
   histogram_tester.ExpectUniqueSample("Autofill.IsEnabled.PageLoad", true, 1);
 }
 
 // Test that we log that Autofill is disabled when filling a form.
 TEST_F(AutofillMetricsTest, AutofillIsDisabledAtPageLoad) {
@@ skipping 18 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) {
+  EnableUkmLogging();
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+
   // 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);
   test::CreateTestFormField("Email", "email", "", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Phone", "phone", "", "text", &field);
   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());
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::Now());
     histogram_tester.ExpectTotalCount("Autofill.FormSubmittedState", 0);
   }
 
   // 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 2 entries for form
+    // interactions. All 3 entries are for the same URL.
+    ASSERT_EQ(3U, ukm_service->entries_count());
+    ASSERT_EQ(2U, ukm_service->sources_count());
+    VerifyDeveloperEngagementUkm(
+        form, ukm_service,
+        {AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS});
+    VerifyUniqueFormInteractionEventUkm(form, ukm_service,
+                                        internal::kUKMUserHappinessMetricName,
+                                        AutofillMetrics::FORMS_LOADED);
+    VerifyUniqueFormInteractionEventUkm(
+        form, ukm_service, internal::kUKMAutofillFormSubmittedStateName,
+        AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA);
+    ukm_service->Purge();
   }
 
   // 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_->form_interactions_ukm_logger()
+        ->set_form_loaded_timestamp(TimeTicks::Now());
     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"));
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 
   // 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_->form_interactions_ukm_logger()
+        ->set_form_loaded_timestamp(TimeTicks::Now());
     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"));
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::
+              FILLABLE_FORM_AUTOFILLED_NONE_DID_NOT_SHOW_SUGGESTIONS}});
+    ukm_service->Purge();
   }
 
   // Autofilled none with suggestions shown.
+  autofill_manager_->form_interactions_ukm_logger()->set_form_loaded_timestamp(
+      TimeTicks::Now());
   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"));
+
+    ASSERT_EQ(2U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAddressFormEventName,
+          AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN},
+         {internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::
+              FILLABLE_FORM_AUTOFILLED_NONE_DID_SHOW_SUGGESTIONS}});
+    ukm_service->Purge();
   }
 
   // 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_->form_interactions_ukm_logger()
+        ->set_form_loaded_timestamp(TimeTicks::Now());
     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"));
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::FILLABLE_FORM_AUTOFILLED_SOME}});
+    ukm_service->Purge();
   }
 
   // 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_->form_interactions_ukm_logger()
+        ->set_form_loaded_timestamp(TimeTicks::Now());
     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"));
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::FILLABLE_FORM_AUTOFILLED_ALL}});
+    ukm_service->Purge();
   }
 
   // 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_->form_interactions_ukm_logger()
+        ->set_form_loaded_timestamp(TimeTicks::Now());
     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"));
+
+    ASSERT_EQ(1U, ukm_service->entries_count());
+    ASSERT_EQ(1U, ukm_service->sources_count());
+    VerifyFormInteractionsUkm(
+        form, ukm_service,
+        {{internal::kUKMAutofillFormSubmittedStateName,
+          AutofillMetrics::NON_FILLABLE_FORM_OR_NEW_DATA}});
+    ukm_service->Purge();
   }
 }
 
 // Verify that we correctly log user happiness metrics dealing with form
 // interaction.
 TEST_F(AutofillMetricsTest, UserHappinessFormInteraction) {
+  EnableUkmLogging();
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+
   // 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);
   test::CreateTestFormField("Email", "email", "", "text", &field);
@@ skipping 79 matching lines @@
   }
 
   // Simulate editing another autofilled field.
   {
     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();
+
+  // Verify UKM logs.
+  VerifyFormInteractionsUkm(
+      form, ukm_service,
+      {{internal::kUKMUserHappinessMetricName, AutofillMetrics::FORMS_LOADED},
+       {internal::kUKMUserHappinessMetricName, AutofillMetrics::USER_DID_TYPE},
+       {internal::kUKMAddressFormEventName,
+        AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN},
+       {internal::kUKMAddressFormEventName,
+        AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN},
+       {internal::kUKMUserHappinessMetricName,
+        AutofillMetrics::USER_DID_AUTOFILL},
+       {internal::kUKMAddressFormEventName,
+        AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED},
+       {internal::kUKMUserHappinessMetricName,
+        AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD},
+       {internal::kUKMUserHappinessMetricName,
+        AutofillMetrics::USER_DID_AUTOFILL},
+       {internal::kUKMUserHappinessMetricName,
+        AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD}});
 }
 
 // Verify that we correctly log metrics tracking the duration of form fill.
 TEST_F(AutofillMetricsTest, FormFillDuration) {
   // 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");
 
@@ skipping 557 matching lines @@
                ["Autofill.FormEvents.CreditCard.OnNonsecurePage"]);
   }
 }
 
 // Tests that logging CardUploadDecision UKM works as expected.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric) {
   EnableUkmLogging();
   ukm::UkmServiceTestingHarness ukm_service_test_harness;
   GURL url("https://www.google.com");
   int upload_decision = 1;
-  std::map<std::string, int> metrics = {
+  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));
 
   // Make sure that the UKM was logged correctly.
   ukm::TestUkmService* ukm_service =
       ukm_service_test_harness.test_ukm_service();
 
@@ skipping 20 matching lines @@
   ASSERT_NE(nullptr, metric);
   EXPECT_EQ(upload_decision, metric->value());
 }
 
 // Tests that logging DeveloperEngagement UKM works as expected.
 TEST_F(AutofillMetricsTest, RecordDeveloperEngagementMetric) {
   EnableUkmLogging();
   ukm::UkmServiceTestingHarness ukm_service_test_harness;
   GURL url("https://www.google.com");
   int form_structure_metric = 1;
-  std::map<std::string, int> metrics = {
+  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));
 
   // Make sure that the UKM was logged correctly.
   ukm::TestUkmService* ukm_service =
       ukm_service_test_harness.test_ukm_service();
 
@@ skipping 19 matching lines @@
       internal::kUKMDeveloperEngagementMetricName, entry_proto.metrics());
   ASSERT_NE(nullptr, metric);
   EXPECT_EQ(form_structure_metric, metric->value());
 }
 
 // Tests that no UKM is logged when the URL is not valid.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_InvalidUrl) {
   EnableUkmLogging();
   ukm::UkmServiceTestingHarness ukm_service_test_harness;
   GURL url("");
-  std::map<std::string, int> metrics = {{"metric", 1}};
+  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());
 }
 
 // Tests that no UKM is logged when the metrics map is empty.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_NoMetrics) {
   EnableUkmLogging();
   ukm::UkmServiceTestingHarness ukm_service_test_harness;
   GURL url("https://www.google.com");
-  std::map<std::string, int> metrics;
+  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());
 }
 
 // Tests that no UKM is logged when the ukm service is null.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_NoUkmService) {
   EnableUkmLogging();
   ukm::UkmServiceTestingHarness ukm_service_test_harness;
   GURL url("https://www.google.com");
-  std::map<std::string, int> metrics = {{"metric", 1}};
+  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());
 }
 
 // Tests that no UKM is logged when the ukm logging feature is disabled.
 TEST_F(AutofillMetricsTest, RecordCardUploadDecisionMetric_FeatureDisabled) {
   ukm::UkmServiceTestingHarness ukm_service_test_harness;
   GURL url("https://www.google.com");
-  std::map<std::string, int> metrics = {{"metric", 1}};
+  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());
 }
 
 }  // namespace autofill