Refactor UKM interface for mojo-ification

components/autofill/core/browser/autofill_manager_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_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 39 matching lines @@
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/autofill_util.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/security_state/core/security_state.h"
 #include "components/strings/grit/components_strings.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/variations/variations_associated_data.h"
 #include "components/variations/variations_params_manager.h"
 #include "net/base/url_util.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 747 matching lines @@
 
   // The query id of the most recent Autofill query.
   int query_id_;
 
   // The results returned by the most recent Autofill query.
   std::vector<Suggestion> suggestions_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillExternalDelegate);
 };
 
-// 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;
-}
-
 // Get Ukm sources from the Ukm service.
-std::vector<const ukm::UkmSource*> GetUkmSources(ukm::TestUkmService* service) {
+std::vector<const ukm::UkmSource*> GetUkmSources(
+    ukm::TestUkmRecorder* service) {
   std::vector<const ukm::UkmSource*> sources;
   for (const auto& kv : service->GetSources())
     sources.push_back(kv.second.get());
 
   return sources;
 }
 
 }  // namespace
 
 class AutofillManagerTest : public testing::Test {
@@ skipping 226 matching lines @@
     scoped_feature_list_.InitWithFeatures(
         {kAutofillUpstreamRequestCvcIfMissing, kAutofillUkmLogging}, {});
   }
 
   void DisableAutofillUpstreamUseAutofillProfileComparatorForName() {
     scoped_feature_list_.InitAndDisableFeature(
         kAutofillUpstreamUseAutofillProfileComparatorForName);
   }
 
   void ExpectUniqueFillableFormParsedUkm() {
-    ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+    ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
     // Check that one source is logged.
-    ASSERT_EQ(1U, ukm_service->sources_count());
-    const ukm::UkmSource* source = GetUkmSources(ukm_service)[0];
+    ASSERT_EQ(1U, ukm_recorder->sources_count());
+    const ukm::UkmSource* source = GetUkmSources(ukm_recorder)[0];
 
     // Check that one entry is logged.
-    EXPECT_EQ(1U, ukm_service->entries_count());
-    const ukm::UkmEntry* entry = ukm_service->GetEntry(0);
-    EXPECT_EQ(source->id(), entry->source_id());
+    EXPECT_EQ(1U, ukm_recorder->entries_count());
+    const ukm::mojom::UkmEntry* entry = ukm_recorder->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(source->id(), entry->source_id);
 
     // Check if there is an entry for developer engagement decision.
     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());
 
     // Check that the expected developer engagement metric is 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(1 << AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS,
-              metric->value());
+              metric->value);
   }
 
   void ExpectUniqueCardUploadDecision(
       const base::HistogramTester& histogram_tester,
       AutofillMetrics::CardUploadDecisionMetric metric) {
     histogram_tester.ExpectUniqueSample("Autofill.CardUploadDecisionMetric",
                                         ToHistogramSample(metric), 1);
   }
 
   void ExpectCardUploadDecision(
@@ skipping 15 matching lines @@
     ExpectMetric(internal::kUKMDeveloperEngagementMetricName,
                  internal::kUKMDeveloperEngagementEntryName,
                  1 << AutofillMetrics::FILLABLE_FORM_PARSED_WITHOUT_TYPE_HINTS,
                  num_fillable_forms_parsed);
   }
 
   void ExpectMetric(const char* metric_name,
                     const char* entry_name,
                     int expected_metric_value,
                     int expected_num_matching_entries) {
-    ukm::TestUkmService* ukm_service = autofill_client_.GetTestUkmService();
+    ukm::TestUkmRecorder* ukm_recorder = autofill_client_.GetTestUkmRecorder();
 
     int num_matching_entries = 0;
-    for (size_t i = 0; i < ukm_service->entries_count(); ++i) {
-      const ukm::UkmEntry* entry = ukm_service->GetEntry(i);
-
-      ukm::Entry entry_proto;
-      entry->PopulateProto(&entry_proto);
-      EXPECT_EQ(entry->source_id(), entry_proto.source_id());
-
+    for (size_t i = 0; i < ukm_recorder->entries_count(); ++i) {
+      const ukm::mojom::UkmEntry* entry = ukm_recorder->GetEntry(i);
       // Check if there is an entry for |entry_name|.
-      if (entry_proto.event_hash() == base::HashMetricName(entry_name)) {
-        EXPECT_EQ(1, entry_proto.metrics_size());
+      if (entry->event_hash == base::HashMetricName(entry_name)) {
+        EXPECT_EQ(1UL, entry->metrics.size());
 
         // Check that the expected |metric_value| is logged.
-        const ukm::Entry_Metric* metric =
-            FindMetric(metric_name, entry_proto.metrics());
+        const ukm::mojom::UkmMetric* metric =
+            ukm::TestUkmRecorder::FindMetric(entry, metric_name);
         ASSERT_NE(nullptr, metric);
-        EXPECT_EQ(expected_metric_value, metric->value());
+        EXPECT_EQ(expected_metric_value, metric->value);
         ++num_matching_entries;
       }
     }
     EXPECT_EQ(expected_num_matching_entries, num_matching_entries);
   }
 
  protected:
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   MockAutofillClient autofill_client_;
   std::unique_ptr<MockAutofillDriver> autofill_driver_;
@@ skipping 2388 matching lines @@
 // Test that OnLoadedServerPredictions can obtain the FormStructure with the
 // signature of the queried form and apply type predictions.
 TEST_F(AutofillManagerTest, OnLoadedServerPredictions) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
 
   // Simulate having seen this form on page load.
   // |form_structure| will be owned by |autofill_manager_|.
   TestFormStructure* form_structure = new TestFormStructure(form);
-  form_structure->DetermineHeuristicTypes(nullptr /* ukm_service */);
+  form_structure->DetermineHeuristicTypes(nullptr /* ukm_recorder */);
   autofill_manager_->AddSeenForm(base::WrapUnique(form_structure));
 
   // Similarly, a second form.
   FormData form2;
   form2.name = ASCIIToUTF16("MyForm");
   form2.origin = GURL("http://myform.com/form.html");
   form2.action = GURL("http://myform.com/submit.html");
 
   FormFieldData field;
   test::CreateTestFormField("Last Name", "lastname", "", "text", &field);
   form2.fields.push_back(field);
 
   test::CreateTestFormField("Middle Name", "middlename", "", "text", &field);
   form2.fields.push_back(field);
 
   test::CreateTestFormField("Postal Code", "zipcode", "", "text", &field);
   form2.fields.push_back(field);
 
   TestFormStructure* form_structure2 = new TestFormStructure(form2);
-  form_structure2->DetermineHeuristicTypes(nullptr /* ukm_service */);
+  form_structure2->DetermineHeuristicTypes(nullptr /* ukm_recorder */);
   autofill_manager_->AddSeenForm(base::WrapUnique(form_structure2));
 
   AutofillQueryResponseContents response;
   response.add_field()->set_autofill_type(3);
   for (int i = 0; i < 7; ++i) {
     response.add_field()->set_autofill_type(0);
   }
   response.add_field()->set_autofill_type(3);
   response.add_field()->set_autofill_type(2);
   response.add_field()->set_autofill_type(61);
@@ skipping 31 matching lines @@
 // AutofillManager has been reset between the time the query was sent and the
 // response received.
 TEST_F(AutofillManagerTest, OnLoadedServerPredictions_ResetManager) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
 
   // Simulate having seen this form on page load.
   // |form_structure| will be owned by |autofill_manager_|.
   TestFormStructure* form_structure = new TestFormStructure(form);
-  form_structure->DetermineHeuristicTypes(nullptr /* ukm_service */);
+  form_structure->DetermineHeuristicTypes(nullptr /* ukm_recorder */);
   autofill_manager_->AddSeenForm(base::WrapUnique(form_structure));
 
   AutofillQueryResponseContents response;
   response.add_field()->set_autofill_type(3);
   for (int i = 0; i < 7; ++i) {
     response.add_field()->set_autofill_type(0);
   }
   response.add_field()->set_autofill_type(3);
   response.add_field()->set_autofill_type(2);
   response.add_field()->set_autofill_type(61);
@@ skipping 17 matching lines @@
 // Test that we are able to save form data when forms are submitted and we only
 // have server data for the field types.
 TEST_F(AutofillManagerTest, FormSubmittedServerTypes) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
 
   // Simulate having seen this form on page load.
   // |form_structure| will be owned by |autofill_manager_|.
   TestFormStructure* form_structure = new TestFormStructure(form);
-  form_structure->DetermineHeuristicTypes(nullptr /* ukm_service */);
+  form_structure->DetermineHeuristicTypes(nullptr /* ukm_recorder */);
 
   // Clear the heuristic types, and instead set the appropriate server types.
   std::vector<ServerFieldType> heuristic_types, server_types;
   for (size_t i = 0; i < form.fields.size(); ++i) {
     heuristic_types.push_back(UNKNOWN_TYPE);
     server_types.push_back(form_structure->field(i)->heuristic_type());
   }
   form_structure->SetFieldTypes(heuristic_types, server_types);
   autofill_manager_->AddSeenForm(base::WrapUnique(form_structure));
 
@@ skipping 3110 matching lines @@
 
   FormFieldData field;
   test::CreateTestFormField("Field 1", "field1", "", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Field 2", "field2", "", "text", &field);
   form.fields.push_back(field);
   test::CreateTestFormField("Field 3", "field3", "", "text", &field);
   form.fields.push_back(field);
 
   auto form_structure = base::MakeUnique<TestFormStructure>(form);
-  form_structure->DetermineHeuristicTypes(nullptr /* ukm_service */);
+  form_structure->DetermineHeuristicTypes(nullptr /* ukm_recorder */);
   // Make sure the form can not be autofilled now.
   ASSERT_EQ(0u, form_structure->autofill_count());
   for (size_t idx = 0; idx < form_structure->field_count(); ++idx) {
     ASSERT_EQ(UNKNOWN_TYPE, form_structure->field(idx)->heuristic_type());
   }
 
   // Prepare and set known server fields.
   const std::vector<ServerFieldType> heuristic_types(form.fields.size(),
                                                      UNKNOWN_TYPE);
   const std::vector<ServerFieldType> server_types{NAME_FIRST, NAME_MIDDLE,
@@ skipping 109 matching lines @@
 
   // Wait for upload to complete (will check expected types as well).
   autofill_manager_->WaitForAsyncUploadProcess();
 
   EXPECT_EQ(signature, autofill_manager_->GetSubmittedFormSignature());
   EXPECT_NE(uploaded_available_types.end(),
             uploaded_available_types.find(autofill::PASSWORD));
 }
 
 }  // namespace autofill