Adds UKM for autofill attributes in form_structure.

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 <map>
 #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 26 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;
 
 namespace autofill {
 namespace {
 
 class TestPersonalDataManager : public PersonalDataManager {
  public:
   TestPersonalDataManager()
       : PersonalDataManager("en-US"),
         autofill_enabled_(true) {
     CreateTestAutofillProfiles(&web_profiles_);
@@ skipping 242 matching lines @@
 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;
 }
 
+// Finds all the UKM values for |name| in the specified |metrics|.
+const std::vector<int64_t> FindMetricValues(
+    const char* name,
+    const google::protobuf::RepeatedPtrField<ukm::Entry_Metric>& metrics) {
+  std::vector<int64_t> values;
+  for (const auto& metric : metrics) {
+    if (metric.metric_hash() == base::HashMetricName(name))
+      values.push_back(metric.value());
+  }
+  return values;
+}
+
 }  // 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 64 matching lines @@
   account_tracker_.reset();
   signin_client_.reset();
   test::ReenableSystemServices();
 }
 
 void AutofillMetricsTest::EnableWalletSync() {
   signin_manager_->SetAuthenticatedAccountInfo("12345", "syncuser@example.com");
 }
 
 void AutofillMetricsTest::EnableUkmLogging() {
   scoped_feature_list_.InitAndEnableFeature(kAutofillUkmLogging);

[Mathieu, 2017/03/27 23:59:31]

Sorry that I didn't catch this earlier, but you might want to check with
privard@ whether this new UKM can fall under the existing kAutofillUkmLogging
feature or we should create a new one. AFAIK, they would like granular control
over which UKM is allowed. 

[csashi, 2017/03/28 00:14:24]

Acknowledged. I remembered that you told me to add a feature but because the UKM
logging feature flag name was generic, I thought the new metric would also be
covered. Will check anyway.

 }
 
 // Test that we log quality metrics appropriately.
 TEST_F(AutofillMetricsTest, QualityMetrics) {
   // 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 345 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();
+  form_structure->DetermineHeuristicTypes(nullptr /* ukm_service */);
   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 647 matching lines @@
   autofill_manager_->RunRunLoop();
 
   // An autofillable form was uploaded, and the number of edited autofilled
   // fields is logged.
   histogram_tester.ExpectUniqueSample(
       "Autofill.NumberOfEditedAutofilledFieldsAtSubmission.NoSubmission", 1, 1);
 }
 
 // Verify that we correctly log metrics regarding developer engagement.
 TEST_F(AutofillMetricsTest, DeveloperEngagement) {
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+
   // 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.
   {
     base::HistogramTester histogram_tester;
     autofill_manager_->OnFormsSeen(forms, TimeTicks());
     autofill_manager_->Reset();
     histogram_tester.ExpectTotalCount("Autofill.DeveloperEngagement", 0);
+
+    // UKM must not be logged unless enabled.
+    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 only the "form parsed" metric to be logged; no metrics about
   // author-specified field type hints.
   {
     base::HistogramTester histogram_tester;
     autofill_manager_->OnFormsSeen(forms, TimeTicks());
     autofill_manager_->Reset();
     histogram_tester.ExpectUniqueSample("Autofill.DeveloperEngagement",
                                         AutofillMetrics::FILLABLE_FORM_PARSED,
                                         1);
+
+    // UKM must not be logged unless enabled.
+    EXPECT_EQ(0U, ukm_service->sources_count());
+    EXPECT_EQ(0U, ukm_service->entries_count());
   }
 
   // Add some fields with an author-specified field type to the form.
   // We need to add at least three fields, because a form must have at least
   // three fillable fields to be considered to be autofillable; and if at least
   // one field specifies an explicit type hint, we don't apply any of our usual
   // local heuristics to detect field types in the rest of the form.
   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 both the "form parsed" metric and the author-specified field type
   // hints metric to be logged.
   {
     base::HistogramTester histogram_tester;
     autofill_manager_->OnFormsSeen(forms, TimeTicks());
     autofill_manager_->Reset();
     histogram_tester.ExpectBucketCount("Autofill.DeveloperEngagement",
                                        AutofillMetrics::FILLABLE_FORM_PARSED,
                                        1);
     histogram_tester.ExpectBucketCount(
         "Autofill.DeveloperEngagement",
         AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS, 1);
+
+    // UKM must not be logged unless enabled.
+    EXPECT_EQ(0U, ukm_service->sources_count());
+    EXPECT_EQ(0U, ukm_service->entries_count());
   }
 }
 
+// Verify that we correctly log UKM regarding developer engagement.
+TEST_F(AutofillMetricsTest, UkmDeveloperEngagement_LogFillableFormParsed) {
+  EnableUkmLogging();
+  ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+
+  // 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());
+    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 only the "form parsed" metric to be logged; no metrics about
+  // author-specified field type hints.
+  {
+    autofill_manager_->OnFormsSeen(forms, TimeTicks());
+    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());
+    EXPECT_THAT(FindMetricValues(internal::kUKMDeveloperEngagementMetricName,
+                                 entry_proto.metrics()),
+                UnorderedElementsAre(AutofillMetrics::FILLABLE_FORM_PARSED));
+  }
+}
+
+// Verify that we correctly log UKM regarding developer engagement.
+TEST_F(AutofillMetricsTest, UkmDeveloperEngagement_LogAllMetrics) {
+  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);
+
+  std::vector<FormData> forms(1, form);
+
+  // Add another field to the form, so that it becomes fillable.
+  test::CreateTestFormField("Phone", "phone", "", "text", &field);
+  forms.back().fields.push_back(field);
+
+  // Add some fields with an author-specified field type to the form.
+  // We need to add at least three fields, because a form must have at least
+  // three fillable fields to be considered to be autofillable; and if at least
+  // one field specifies an explicit type hint, we don't apply any of our usual
+  // local heuristics to detect field types in the rest of the form.
+  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 both the "form parsed" metric and the author-specified field type
+  // hints metric to be logged.
+  {
+    autofill_manager_->OnFormsSeen(forms, TimeTicks());
+    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());
+    EXPECT_THAT(FindMetricValues(internal::kUKMDeveloperEngagementMetricName,
+                                 entry_proto.metrics()),
+                UnorderedElementsAre(
+                    AutofillMetrics::FILLABLE_FORM_PARSED,
+                    AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS));
+  }
+}
+
 // 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);
   }
 
   // The metric should only be logged once.
@@ skipping 2845 matching lines @@
         "Autofill.FormEvents.CreditCard",
         AutofillMetrics::FORM_EVENT_NO_SUGGESTION_SUBMITTED_ONCE, 1);
     // 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 a UKM works as expected.
+// 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;
-  metrics.insert(std::make_pair(internal::kUKMCardUploadDecisionMetricName,
-                                upload_decision));
+  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();
 
   ASSERT_EQ(1U, ukm_service->sources_count());
   const ukm::UkmSource* source =
       ukm_service->GetSourceForUrl(url.spec().c_str());
   EXPECT_EQ(url.spec(), source->url().spec());
 
-  EXPECT_EQ(1U, ukm_service->entries_count());
+  ASSERT_EQ(1U, ukm_service->entries_count());
   const ukm::UkmEntry* entry = ukm_service->GetEntry(0);
   EXPECT_EQ(source->id(), entry->source_id());
 
-  // Make sure that an card upload decision entry was logged.
+  // 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(base::HashMetricName(internal::kUKMCardUploadDecisionEntryName),
             entry_proto.event_hash());
   EXPECT_EQ(1, entry_proto.metrics_size());
 
   // Make sure that the correct upload decision was logged.
   const ukm::Entry_Metric* metric = FindMetric(
       internal::kUKMCardUploadDecisionMetricName, entry_proto.metrics());
   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::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();
+
+  ASSERT_EQ(1U, ukm_service->sources_count());
+  const ukm::UkmSource* source =
+      ukm_service->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());
+
+  // 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(base::HashMetricName(internal::kUKMDeveloperEngagementEntryName),
+            entry_proto.event_hash());
+  EXPECT_EQ(1, entry_proto.metrics_size());
+
+  // Make sure that the correct developer engagement metric was logged.
+  const ukm::Entry_Metric* metric = FindMetric(
+      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;
-  metrics.insert(std::make_pair("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;
-  metrics.insert(std::make_pair("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;
-  metrics.insert(std::make_pair("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