[Autofill] Add upstreaming UKM

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 <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"
+#include "base/test/scoped_feature_list.h"
 #include "base/test/user_action_tester.h"
 #include "base/time/time.h"
+#include "components/autofill/core/browser/autofill_experiments.h"
 #include "components/autofill/core/browser/autofill_external_delegate.h"
 #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/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;
 using rappor::TestRapporServiceImpl;
@@ skipping 242 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;
+}
+
 }  // 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;
 
   void SetUp() override;
   void TearDown() override;
 
  protected:
   void EnableWalletSync();
+  void EnableUkmLogging();
 
   base::MessageLoop message_loop_;
   TestAutofillClient autofill_client_;
   std::unique_ptr<AccountTrackerService> account_tracker_;
   std::unique_ptr<FakeSigninManagerBase> signin_manager_;
   std::unique_ptr<TestSigninClient> signin_client_;
   std::unique_ptr<TestAutofillDriver> autofill_driver_;
   std::unique_ptr<TestAutofillManager> autofill_manager_;
   std::unique_ptr<TestPersonalDataManager> personal_data_;
   std::unique_ptr<AutofillExternalDelegate> external_delegate_;
+  base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 AutofillMetricsTest::~AutofillMetricsTest() {
   // Order of destruction is important as AutofillManager relies on
   // PersonalDataManager to be around when it gets destroyed.
   autofill_manager_.reset();
 }
 
 void AutofillMetricsTest::SetUp() {
   autofill_client_.SetPrefs(test::PrefServiceForTesting());
@@ skipping 36 matching lines @@
   account_tracker_->Shutdown();
   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);
+}
+
 // 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");
 
   std::vector<ServerFieldType> heuristic_types, server_types;
   FormFieldData field;
@@ skipping 3943 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.
+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));
+
+  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->GetSource(0);
+  EXPECT_EQ(url.spec(), source->url().spec());
+
+  EXPECT_EQ(1U, ukm_service->entries_count());
+  const ukm::UkmEntry* entry = ukm_service->GetEntry(0);
+  EXPECT_EQ(entry->source_id(), source->id());
+
+  // Make sure that an card upload decision entry was logged.
+  ukm::Entry entry_proto;
+  entry->PopulateProto(&entry_proto);
+  EXPECT_EQ(entry_proto.source_id(), source->id());
+  EXPECT_EQ(entry_proto.event_hash(),

[rkaplow, 2017/03/10 19:00:27]

similar comment re: expect ordering

[sebsg, 2017/03/10 19:25:33]

Done.

+            base::HashMetricName(internal::kUKMCardUploadDecisionEntryName));
+  EXPECT_EQ(entry_proto.metrics_size(), 1);
+
+  // 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 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));
+
+  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;
+
+  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));
+
+  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));
+
+  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