Refactor UKM interface for mojo-ification

components/autofill/core/browser/autofill_metrics.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 <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "base/time/time.h"
 #include "components/autofill/core/browser/autofill_experiments.h"
 #include "components/autofill/core/browser/autofill_field.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/common/form_data.h"
-#include "components/ukm/ukm_entry_builder.h"
+#include "components/ukm/public/ukm_entry_builder.h"
 
 namespace internal {
 const char kUKMCardUploadDecisionEntryName[] = "Autofill.CardUploadDecision";
 const char kUKMCardUploadDecisionMetricName[] = "UploadDecision";
 const char kUKMDeveloperEngagementEntryName[] = "Autofill.DeveloperEngagement";
 const char kUKMDeveloperEngagementMetricName[] = "DeveloperEngagement";
 const char kUKMMillisecondsSinceFormParsedMetricName[] =
     "MillisecondsSinceFormParsed";
 const char kUKMInteractedWithFormEntryName[] = "Autofill.InteractedWithForm";
 const char kUKMIsForCreditCardMetricName[] = "IsForCreditCard";
@@ skipping 721 matching lines @@
                             NUM_CONVERTED_ADDRESS_CONVERSION_TYPES);
 }
 
 // static
 void AutofillMetrics::LogShowedHttpNotSecureExplanation() {
   base::RecordAction(
       base::UserMetricsAction("Autofill_ShowedHttpNotSecureExplanation"));
 }
 
 // static
-void AutofillMetrics::LogCardUploadDecisionsUkm(ukm::UkmService* ukm_service,
+void AutofillMetrics::LogCardUploadDecisionsUkm(ukm::UkmRecorder* ukm_recorder,
                                                 const GURL& url,
                                                 int upload_decision_metrics) {
   DCHECK(upload_decision_metrics);
   DCHECK_LT(upload_decision_metrics, 1 << kNumCardUploadDecisionMetrics);
 
   const std::vector<std::pair<const char*, int>> metrics = {
       {internal::kUKMCardUploadDecisionMetricName, upload_decision_metrics}};
-  LogUkm(ukm_service, url, internal::kUKMCardUploadDecisionEntryName, metrics);
+  LogUkm(ukm_recorder, url, internal::kUKMCardUploadDecisionEntryName, metrics);
 }
 
 // static
 void AutofillMetrics::LogDeveloperEngagementUkm(
-    ukm::UkmService* ukm_service,
+    ukm::UkmRecorder* ukm_recorder,
     const GURL& url,
     int developer_engagement_metrics) {
   DCHECK(developer_engagement_metrics);
   DCHECK_LT(developer_engagement_metrics,
             1 << NUM_DEVELOPER_ENGAGEMENT_METRICS);
 
   const std::vector<std::pair<const char*, int>> metrics = {
       {internal::kUKMDeveloperEngagementMetricName,
        developer_engagement_metrics}};
 
-  LogUkm(ukm_service, url, internal::kUKMDeveloperEngagementEntryName, metrics);
+  LogUkm(ukm_recorder, url, internal::kUKMDeveloperEngagementEntryName,
+         metrics);
 }
 
 // static
 bool AutofillMetrics::LogUkm(
-    ukm::UkmService* ukm_service,
+    ukm::UkmRecorder* ukm_recorder,
     const GURL& url,
     const std::string& ukm_entry_name,
     const std::vector<std::pair<const char*, int>>& metrics) {
-  if (!ukm_service || !url.is_valid() || metrics.empty()) {
+  if (!ukm_recorder || !url.is_valid() || metrics.empty()) {
     return false;
   }
 
-  int32_t source_id = ukm_service->GetNewSourceID();
-  ukm_service->UpdateSourceURL(source_id, url);
+  ukm::SourceId source_id = ukm_recorder->GetNewSourceID();
+  ukm_recorder->UpdateSourceURL(source_id, url);
   std::unique_ptr<ukm::UkmEntryBuilder> builder =
-      ukm_service->GetEntryBuilder(source_id, ukm_entry_name.c_str());
+      ukm_recorder->GetEntryBuilder(source_id, ukm_entry_name.c_str());
 
   for (auto it = metrics.begin(); it != metrics.end(); ++it) {
     builder->AddMetric(it->first, it->second);
   }
 
   return true;
 }
 
 AutofillMetrics::FormEventLogger::FormEventLogger(
     bool is_for_credit_card,
@@ skipping 208 matching lines @@
   else if (server_record_type_count_ > 0 && local_record_type_count_ == 0)
     name += ".WithOnlyServerData";
   else if (server_record_type_count_ == 0 && local_record_type_count_ > 0)
     name += ".WithOnlyLocalData";
   else
     name += ".WithBothServerAndLocalData";
   LogUMAHistogramEnumeration(name, event, NUM_FORM_EVENTS);
 }
 
 AutofillMetrics::FormInteractionsUkmLogger::FormInteractionsUkmLogger(
-    ukm::UkmService* ukm_service)
-    : ukm_service_(ukm_service) {}
+    ukm::UkmRecorder* ukm_recorder)
+    : ukm_recorder_(ukm_recorder) {}
 
 void AutofillMetrics::FormInteractionsUkmLogger::OnFormsParsed(
     const GURL& url) {
-  if (ukm_service_ == nullptr)
+  if (ukm_recorder_ == nullptr)
     return;
 
   url_ = url;
   form_parsed_timestamp_ = base::TimeTicks::Now();
 }
 
 void AutofillMetrics::FormInteractionsUkmLogger::LogInteractedWithForm(
     bool is_for_credit_card,
     size_t local_record_type_count,
     size_t server_record_type_count) {
   if (!CanLog())
     return;
 
   if (source_id_ == -1)
     GetNewSourceID();
 
-  std::unique_ptr<ukm::UkmEntryBuilder> builder = ukm_service_->GetEntryBuilder(
-      source_id_, internal::kUKMInteractedWithFormEntryName);
+  std::unique_ptr<ukm::UkmEntryBuilder> builder =
+      ukm_recorder_->GetEntryBuilder(source_id_,
+                                     internal::kUKMInteractedWithFormEntryName);
   builder->AddMetric(internal::kUKMIsForCreditCardMetricName,
                      is_for_credit_card);
   builder->AddMetric(internal::kUKMLocalRecordTypeCountMetricName,
                      local_record_type_count);
   builder->AddMetric(internal::kUKMServerRecordTypeCountMetricName,
                      server_record_type_count);
 }
 
 void AutofillMetrics::FormInteractionsUkmLogger::LogSuggestionsShown() {
   if (!CanLog())
     return;
 
   if (source_id_ == -1)
     GetNewSourceID();
 
-  std::unique_ptr<ukm::UkmEntryBuilder> builder = ukm_service_->GetEntryBuilder(
-      source_id_, internal::kUKMSuggestionsShownEntryName);
+  std::unique_ptr<ukm::UkmEntryBuilder> builder =
+      ukm_recorder_->GetEntryBuilder(source_id_,
+                                     internal::kUKMSuggestionsShownEntryName);
   builder->AddMetric(internal::kUKMMillisecondsSinceFormParsedMetricName,
                      MillisecondsSinceFormParsed());
 }
 
 void AutofillMetrics::FormInteractionsUkmLogger::LogSelectedMaskedServerCard() {
   if (!CanLog())
     return;
 
   if (source_id_ == -1)
     GetNewSourceID();
 
-  std::unique_ptr<ukm::UkmEntryBuilder> builder = ukm_service_->GetEntryBuilder(
-      source_id_, internal::kUKMSelectedMaskedServerCardEntryName);
+  std::unique_ptr<ukm::UkmEntryBuilder> builder =
+      ukm_recorder_->GetEntryBuilder(
+          source_id_, internal::kUKMSelectedMaskedServerCardEntryName);
   builder->AddMetric(internal::kUKMMillisecondsSinceFormParsedMetricName,
                      MillisecondsSinceFormParsed());
 }
 
 void AutofillMetrics::FormInteractionsUkmLogger::LogDidFillSuggestion(
     int record_type) {
   if (!CanLog())
     return;
 
   if (source_id_ == -1)
     GetNewSourceID();
 
-  std::unique_ptr<ukm::UkmEntryBuilder> builder = ukm_service_->GetEntryBuilder(
-      source_id_, internal::kUKMSuggestionFilledEntryName);
+  std::unique_ptr<ukm::UkmEntryBuilder> builder =
+      ukm_recorder_->GetEntryBuilder(source_id_,
+                                     internal::kUKMSuggestionFilledEntryName);
   builder->AddMetric(internal::kUKMRecordTypeMetricName, record_type);
   builder->AddMetric(internal::kUKMMillisecondsSinceFormParsedMetricName,
                      MillisecondsSinceFormParsed());
 }
 
 void AutofillMetrics::FormInteractionsUkmLogger::LogTextFieldDidChange(
     const AutofillField& field) {
   if (!CanLog())
     return;
 
   if (source_id_ == -1)
     GetNewSourceID();
 
-  std::unique_ptr<ukm::UkmEntryBuilder> builder = ukm_service_->GetEntryBuilder(
-      source_id_, internal::kUKMTextFieldDidChangeEntryName);
+  std::unique_ptr<ukm::UkmEntryBuilder> builder =
+      ukm_recorder_->GetEntryBuilder(source_id_,
+                                     internal::kUKMTextFieldDidChangeEntryName);
   builder->AddMetric(internal::kUKMFieldTypeGroupMetricName,
                      static_cast<int>(field.Type().group()));
   builder->AddMetric(internal::kUKMHeuristicTypeMetricName,
                      static_cast<int>(field.heuristic_type()));
   builder->AddMetric(internal::kUKMServerTypeMetricName,
                      static_cast<int>(field.server_type()));
   builder->AddMetric(internal::kUKMHtmlFieldTypeMetricName,
                      static_cast<int>(field.html_type()));
   builder->AddMetric(internal::kUKMHtmlFieldModeMetricName,
                      static_cast<int>(field.html_mode()));
   builder->AddMetric(internal::kUKMIsAutofilledMetricName, field.is_autofilled);
   builder->AddMetric(internal::kUKMIsEmptyMetricName, field.IsEmpty());
   builder->AddMetric(internal::kUKMMillisecondsSinceFormParsedMetricName,
                      MillisecondsSinceFormParsed());
 }
 
 void AutofillMetrics::FormInteractionsUkmLogger::LogFormSubmitted(
     AutofillFormSubmittedState state) {
   if (!CanLog())
     return;
 
   if (source_id_ == -1)
     GetNewSourceID();
 
-  std::unique_ptr<ukm::UkmEntryBuilder> builder = ukm_service_->GetEntryBuilder(
-      source_id_, internal::kUKMFormSubmittedEntryName);
+  std::unique_ptr<ukm::UkmEntryBuilder> builder =
+      ukm_recorder_->GetEntryBuilder(source_id_,
+                                     internal::kUKMFormSubmittedEntryName);
   builder->AddMetric(internal::kUKMAutofillFormSubmittedStateMetricName,
                      static_cast<int>(state));
   if (form_parsed_timestamp_.is_null())
     DCHECK(state == NON_FILLABLE_FORM_OR_NEW_DATA ||
            state == FILLABLE_FORM_AUTOFILLED_NONE_DID_NOT_SHOW_SUGGESTIONS)
         << state;
   else
     builder->AddMetric(internal::kUKMMillisecondsSinceFormParsedMetricName,
                        MillisecondsSinceFormParsed());
 }
 
 void AutofillMetrics::FormInteractionsUkmLogger::UpdateSourceURL(
     const GURL& url) {
   url_ = url;
   if (CanLog())
-    ukm_service_->UpdateSourceURL(source_id_, url_);
+    ukm_recorder_->UpdateSourceURL(source_id_, url_);
 }
 
 bool AutofillMetrics::FormInteractionsUkmLogger::CanLog() const {
-  return ukm_service_ && url_.is_valid();
+  return ukm_recorder_ && url_.is_valid();
 }
 
 int64_t
 AutofillMetrics::FormInteractionsUkmLogger::MillisecondsSinceFormParsed()
     const {
   DCHECK(!form_parsed_timestamp_.is_null());
   return (base::TimeTicks::Now() - form_parsed_timestamp_).InMilliseconds();
 }
 
 void AutofillMetrics::FormInteractionsUkmLogger::GetNewSourceID() {
-  source_id_ = ukm_service_->GetNewSourceID();
-  ukm_service_->UpdateSourceURL(source_id_, url_);
+  source_id_ = ukm_recorder_->GetNewSourceID();
+  ukm_recorder_->UpdateSourceURL(source_id_, url_);
 }
 
 }  // namespace autofill