UKM that threads together multiple form interaction events.

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_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"
 
 namespace internal {
 const char kUKMCardUploadDecisionEntryName[] = "Autofill.CardUploadDecision";
 const char kUKMCardUploadDecisionMetricName[] = "UploadDecision";
 const char kUKMDeveloperEngagementEntryName[] = "Autofill.DeveloperEngagement";
 const char kUKMDeveloperEngagementMetricName[] = "DeveloperEngagement";
+const char kUKMFormInteractionsEntryName[] = "Autofill.FormInteractions";
+const char kUKMFormInteractionsAutofillFormSubmittedStateMetricName[] =
+    "AutofillFormSubmittedState";
+const char kUKMFormInteractionsUserHappinessMetricMetricName[] =
+    "UserHappinessMetric";
+const char kUKMFormInteractionsAddressFormEventMetricName[] =
+    "FormEvent.Address";
+const char kUKMFormInteractionsCreditCardFormEventMetricName[] =
+    "FormEvent.CreditCard";
+const char kUKMFormInteractionsUnmaskPromptEventMetricName[] =
+    "UnmaskPromptEvent";
 }  // namespace internal
 
 namespace autofill {
 
 namespace {
 
 // Note: if adding an enum value here, update the corresponding description for
 // AutofillTypeQualityByFieldType in histograms.xml.
 enum FieldTypeGroupForMetrics {
   GROUP_AMBIGUOUS = 0,
@@ skipping 574 matching lines @@
 
 // static
 void AutofillMetrics::LogProfileActionOnFormSubmitted(
     AutofillProfileAction action) {
   UMA_HISTOGRAM_ENUMERATION("Autofill.ProfileActionOnFormSubmitted", action,
                             AUTOFILL_PROFILE_ACTION_ENUM_SIZE);
 }
 
 // static
 void AutofillMetrics::LogAutofillFormSubmittedState(
-    AutofillFormSubmittedState state) {
+    AutofillFormSubmittedState state,
+    AutofillMetrics::UkmLogger* ukm_logger) {
   UMA_HISTOGRAM_ENUMERATION("Autofill.FormSubmittedState", state,
                             AUTOFILL_FORM_SUBMITTED_STATE_ENUM_SIZE);
 
   switch (state) {
     case NON_FILLABLE_FORM_OR_NEW_DATA:
       base::RecordAction(
           base::UserMetricsAction("Autofill_FormSubmitted_NonFillable"));
       break;
 
     case FILLABLE_FORM_AUTOFILLED_ALL:
@@ skipping 13 matching lines @@
 
     case FILLABLE_FORM_AUTOFILLED_NONE_DID_NOT_SHOW_SUGGESTIONS:
       base::RecordAction(base::UserMetricsAction(
           "Autofill_FormSubmitted_FilledNone_SuggestionsNotShown"));
       break;
 
     default:
       NOTREACHED();
       break;
   }
+  ukm_logger->LogAutofillFormSubmittedState(state);
 }
 
 // static
 void AutofillMetrics::LogDetermineHeuristicTypesTiming(
     const base::TimeDelta& duration) {
   UMA_HISTOGRAM_TIMES("Autofill.Timing.DetermineHeuristicTypes", duration);
 }
 
 // static
 void AutofillMetrics::LogParseFormTiming(const base::TimeDelta& duration) {
@@ skipping 36 matching lines @@
 }
 
 // static
 void AutofillMetrics::LogCardUploadDecisionUkm(
     ukm::UkmService* ukm_service,
     const GURL& url,
     AutofillMetrics::CardUploadDecisionMetric upload_decision) {
   if (upload_decision >= AutofillMetrics::NUM_CARD_UPLOAD_DECISION_METRICS)
     return;
 
-  const std::map<std::string, int> metrics = {
+  const std::vector<std::pair<const char*, int>> metrics = {
       {internal::kUKMCardUploadDecisionMetricName,
        static_cast<int>(upload_decision)}};
   LogUkm(ukm_service, url, internal::kUKMCardUploadDecisionEntryName, metrics);
 }
 
 // static
 void AutofillMetrics::LogDeveloperEngagementUkm(
     ukm::UkmService* ukm_service,
     const GURL& url,
     AutofillMetrics::DeveloperEngagementMetric metric) {
-  const std::map<std::string, int> form_structure_metrics = {
+  const std::vector<std::pair<const char*, int>> form_structure_metrics = {
       {internal::kUKMDeveloperEngagementMetricName, static_cast<int>(metric)}};
   LogUkm(ukm_service, url, internal::kUKMDeveloperEngagementEntryName,
          form_structure_metrics);
 }
 
 // static
-bool AutofillMetrics::LogUkm(ukm::UkmService* ukm_service,
-                             const GURL& url,
-                             const std::string& ukm_entry_name,
-                             const std::map<std::string, int>& metrics) {
+bool AutofillMetrics::LogUkm(
+    ukm::UkmService* ukm_service,
+    const GURL& url,
+    const std::string& ukm_entry_name,
+    const std::vector<std::pair<const char*, int>>& metrics) {
   if (!IsUkmLoggingEnabled() || !ukm_service || !url.is_valid() ||
       metrics.empty()) {
     return false;
   }
 
   int32_t source_id = ukm_service->GetNewSourceID();
   ukm_service->UpdateSourceURL(source_id, url);
   std::unique_ptr<ukm::UkmEntryBuilder> builder =
       ukm_service->GetEntryBuilder(source_id, ukm_entry_name.c_str());
 
   for (auto it = metrics.begin(); it != metrics.end(); ++it) {
-    builder->AddMetric(it->first.c_str(), it->second);
+    builder->AddMetric(it->first, it->second);
   }
 
   return true;
 }
 
-AutofillMetrics::FormEventLogger::FormEventLogger(bool is_for_credit_card)
+AutofillMetrics::FormEventLogger::FormEventLogger(
+    bool is_for_credit_card,
+    AutofillMetrics::UkmLogger* ukm_logger)
     : is_for_credit_card_(is_for_credit_card),
       is_server_data_available_(false),
       is_local_data_available_(false),
       is_context_secure_(false),
       has_logged_interacted_(false),
       has_logged_suggestions_shown_(false),
       has_logged_masked_server_card_suggestion_selected_(false),
       has_logged_suggestion_filled_(false),
       has_logged_will_submit_(false),
       has_logged_submitted_(false),
       logged_suggestion_filled_was_server_data_(false),
-      logged_suggestion_filled_was_masked_server_card_(false) {}
+      logged_suggestion_filled_was_masked_server_card_(false),
+      ukm_logger_(ukm_logger) {}
 
 void AutofillMetrics::FormEventLogger::OnDidInteractWithAutofillableForm() {
   if (!has_logged_interacted_) {
     has_logged_interacted_ = true;
-    Log(AutofillMetrics::FORM_EVENT_INTERACTED_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_INTERACTED_ONCE, false /* log_ukm */);
   }
 }
 
 void AutofillMetrics::FormEventLogger::OnDidPollSuggestions(
     const FormFieldData& field) {
   // Record only one poll user action for consecutive polls of the same field.
   // This is to avoid recording too many poll actions (for example when a user
   // types in a field, triggering multiple queries) to make the analysis more
   // simple.
   if (!field.SameFieldAs(last_polled_field_)) {
     if (is_for_credit_card_) {
       base::RecordAction(
           base::UserMetricsAction("Autofill_PolledCreditCardSuggestions"));
     } else {
       base::RecordAction(
           base::UserMetricsAction("Autofill_PolledProfileSuggestions"));
     }
 
     last_polled_field_ = field;
   }
 }
 
 void AutofillMetrics::FormEventLogger::OnDidShowSuggestions() {
-  Log(AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN);
+  Log(AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN, true /* log_ukm */);
   if (!has_logged_suggestions_shown_) {
     has_logged_suggestions_shown_ = true;
-    Log(AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_SUGGESTIONS_SHOWN_ONCE,
+        false /* log_ukm */);
   }
 
   if (is_for_credit_card_) {
     base::RecordAction(
         base::UserMetricsAction("Autofill_ShowedCreditCardSuggestions"));
   } else {
     base::RecordAction(
         base::UserMetricsAction("Autofill_ShowedProfileSuggestions"));
   }
 }
 
 void AutofillMetrics::FormEventLogger::OnDidSelectMaskedServerCardSuggestion() {
   DCHECK(is_for_credit_card_);
-  Log(AutofillMetrics::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_SELECTED);
+  Log(AutofillMetrics::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_SELECTED,
+      true /* log_ukm */);
   if (!has_logged_masked_server_card_suggestion_selected_) {
     has_logged_masked_server_card_suggestion_selected_ = true;
-    Log(AutofillMetrics
-            ::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_SELECTED_ONCE);
+    Log(AutofillMetrics ::
+            FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_SELECTED_ONCE,
+        false /* log_ukm */);
   }
 }
 
 void AutofillMetrics::FormEventLogger::OnDidFillSuggestion(
     const CreditCard& credit_card) {
   DCHECK(is_for_credit_card_);
   if (credit_card.record_type() == CreditCard::MASKED_SERVER_CARD)
-    Log(AutofillMetrics::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_FILLED);
+    Log(AutofillMetrics::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_FILLED,
+        true /* log_ukm */);
   else if (credit_card.record_type() == CreditCard::FULL_SERVER_CARD)
-    Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED);
+    Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED,
+        true /* log_ukm */);
   else
-    Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED);
+    Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED,
+        true /* log_ukm */);
 
   if (!has_logged_suggestion_filled_) {
     has_logged_suggestion_filled_ = true;
     logged_suggestion_filled_was_server_data_ =
         credit_card.record_type() == CreditCard::MASKED_SERVER_CARD ||
         credit_card.record_type() == CreditCard::FULL_SERVER_CARD;
     logged_suggestion_filled_was_masked_server_card_ =
         credit_card.record_type() == CreditCard::MASKED_SERVER_CARD;
     if (credit_card.record_type() == CreditCard::MASKED_SERVER_CARD) {
-      Log(AutofillMetrics
-              ::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_FILLED_ONCE);
+      Log(AutofillMetrics ::
+              FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_FILLED_ONCE,
+          false /* log_ukm */);
     } else if (credit_card.record_type() == CreditCard::FULL_SERVER_CARD) {
-      Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED_ONCE);
+      Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED_ONCE,
+          false /* log_ukm */);
     } else {
-      Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED_ONCE);
+      Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED_ONCE,
+          false /* log_ukm */);
     }
   }
 
   base::RecordAction(
       base::UserMetricsAction("Autofill_FilledCreditCardSuggestion"));
 }
 
 void AutofillMetrics::FormEventLogger::OnDidFillSuggestion(
     const AutofillProfile& profile) {
   DCHECK(!is_for_credit_card_);
   if (profile.record_type() == AutofillProfile::SERVER_PROFILE)
-    Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED);
+    Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED,
+        true /* log_ukm */);
   else
-    Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED);
+    Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED,
+        true /* log_ukm */);
 
   if (!has_logged_suggestion_filled_) {
     has_logged_suggestion_filled_ = true;
     logged_suggestion_filled_was_server_data_ =
         profile.record_type() == AutofillProfile::SERVER_PROFILE;
     Log(profile.record_type() == AutofillProfile::SERVER_PROFILE
-        ? AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED_ONCE
-        : AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED_ONCE);
+            ? AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_FILLED_ONCE
+            : AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_FILLED_ONCE,
+        false /* log_ukm */);
   }
 
   base::RecordAction(
       base::UserMetricsAction("Autofill_FilledProfileSuggestion"));
 }
 
 void AutofillMetrics::FormEventLogger::OnWillSubmitForm() {
   // Not logging this kind of form if we haven't logged a user interaction.
   if (!has_logged_interacted_)
     return;
 
   // Not logging twice.
   if (has_logged_will_submit_)
     return;
   has_logged_will_submit_ = true;
 
   if (!has_logged_suggestion_filled_) {
-    Log(AutofillMetrics::FORM_EVENT_NO_SUGGESTION_WILL_SUBMIT_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_NO_SUGGESTION_WILL_SUBMIT_ONCE,
+        false /* log_ukm */);
   } else if (logged_suggestion_filled_was_masked_server_card_) {
     Log(AutofillMetrics::
-            FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_WILL_SUBMIT_ONCE);
+            FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_WILL_SUBMIT_ONCE,
+        false /* log_ukm */);
   } else if (logged_suggestion_filled_was_server_data_) {
-    Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_WILL_SUBMIT_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_WILL_SUBMIT_ONCE,
+        false /* log_ukm */);
   } else {
-    Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_WILL_SUBMIT_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_WILL_SUBMIT_ONCE,
+        false /* log_ukm */);
   }
 
   if (has_logged_suggestions_shown_) {
-    Log(AutofillMetrics::FORM_EVENT_SUGGESTION_SHOWN_WILL_SUBMIT_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_SUGGESTION_SHOWN_WILL_SUBMIT_ONCE,
+        false /* log_ukm */);
   }
 
   base::RecordAction(base::UserMetricsAction("Autofill_OnWillSubmitForm"));
 }
 
 void AutofillMetrics::FormEventLogger::OnFormSubmitted() {
   // Not logging this kind of form if we haven't logged a user interaction.
   if (!has_logged_interacted_)
     return;
 
   // Not logging twice.
   if (has_logged_submitted_)
     return;
   has_logged_submitted_ = true;
 
   if (!has_logged_suggestion_filled_) {
-    Log(AutofillMetrics::FORM_EVENT_NO_SUGGESTION_SUBMITTED_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_NO_SUGGESTION_SUBMITTED_ONCE,
+        false /* log_ukm */);
   } else if (logged_suggestion_filled_was_masked_server_card_) {
-    Log(AutofillMetrics
-            ::FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_SUBMITTED_ONCE);
+    Log(AutofillMetrics ::
+            FORM_EVENT_MASKED_SERVER_CARD_SUGGESTION_SUBMITTED_ONCE,
+        false /* log_ukm */);
   } else if (logged_suggestion_filled_was_server_data_) {
-    Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_SUBMITTED_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_SERVER_SUGGESTION_SUBMITTED_ONCE,
+        false /* log_ukm */);
   } else {
-    Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_SUBMITTED_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_LOCAL_SUGGESTION_SUBMITTED_ONCE,
+        false /* log_ukm */);
   }
 
   if (has_logged_suggestions_shown_) {
-    Log(AutofillMetrics::FORM_EVENT_SUGGESTION_SHOWN_SUBMITTED_ONCE);
+    Log(AutofillMetrics::FORM_EVENT_SUGGESTION_SHOWN_SUBMITTED_ONCE,
+        false /* log_ukm */);
   }
 }
 
-void AutofillMetrics::FormEventLogger::Log(FormEvent event) const {
+void AutofillMetrics::FormEventLogger::Log(FormEvent event,
+                                           bool log_ukm) const {
   DCHECK_LT(event, NUM_FORM_EVENTS);
   std::string name("Autofill.FormEvents.");
   if (is_for_credit_card_)
     name += "CreditCard";
   else
     name += "Address";
   LogUMAHistogramEnumeration(name, event, NUM_FORM_EVENTS);
 
   // Log again in a different histogram for credit card forms on nonsecure
   // pages, so that form interactions on nonsecure pages can be analyzed on
   // their own.
   if (is_for_credit_card_ && !is_context_secure_) {
     LogUMAHistogramEnumeration(name + ".OnNonsecurePage", event,
                                NUM_FORM_EVENTS);
   }
 
   // Logging again in a different histogram for segmentation purposes.
   // TODO(waltercacau): Re-evaluate if we still need such fine grained
   // segmentation. http://crbug.com/454018
   if (!is_server_data_available_ && !is_local_data_available_)
     name += ".WithNoData";
   else if (is_server_data_available_ && !is_local_data_available_)
     name += ".WithOnlyServerData";
   else if (!is_server_data_available_ && is_local_data_available_)
     name += ".WithOnlyLocalData";
   else
     name += ".WithBothServerAndLocalData";
   LogUMAHistogramEnumeration(name, event, NUM_FORM_EVENTS);
+
+  if (log_ukm) {
+    if (is_for_credit_card_)
+      ukm_logger_->LogCreditCardFormEvent(event);
+    else
+      ukm_logger_->LogAddressFormEvent(event);
+  }
+}
+
+AutofillMetrics::UkmLogger::UkmLogger(ukm::UkmService* ukm_service)
+    : ukm_service_(ukm_service) {}
+
+AutofillMetrics::UkmLogger::~UkmLogger() {
+  LogUkm();

[sebsg, 2017/04/10 19:20:19]

Please add a comment to explain why it's useful to log here. Thanks!

[csashi, 2017/04/10 20:15:57]

Done.

+}
+
+void AutofillMetrics::UkmLogger::LogAutofillFormSubmittedState(
+    AutofillFormSubmittedState state) {
+  metrics_.push_back(
+      std::make_pair(AUTOFILL_FORM_SUBMITTED_STATE, static_cast<int>(state)));
+  // User submitted form, we can finalize the events for this form.
+  LogUkm();
+}
+
+void AutofillMetrics::UkmLogger::LogUserHappinessMetric(
+    UserHappinessMetric metric) {
+  metrics_.push_back(
+      std::make_pair(USER_HAPPINESS_METRIC, static_cast<int>(metric)));
+}
+
+void AutofillMetrics::UkmLogger::LogAddressFormEvent(FormEvent event) {
+  metrics_.push_back(
+      std::make_pair(ADDRESS_FORM_EVENT, static_cast<int>(event)));
+}
+
+void AutofillMetrics::UkmLogger::LogCreditCardFormEvent(FormEvent event) {
+  metrics_.push_back(
+      std::make_pair(CREDIT_CARD_FORM_EVENT, static_cast<int>(event)));
+}
+
+void AutofillMetrics::UkmLogger::LogUnmaskPromptEvent(UnmaskPromptEvent event) {
+  metrics_.push_back(
+      std::make_pair(UNMASK_PROMPT_EVENT, static_cast<int>(event)));
+}
+
+void AutofillMetrics::UkmLogger::LogUkm() {

[sebsg, 2017/04/10 19:20:19]

I would change either this one or the others to reflect that this one actually
submits the metrics? maybe this one should be SubmitUkm? Or the others
RecordUserHappinessMetrics or something?

[csashi, 2017/04/10 20:15:58]

Done.

+  std::vector<std::pair<const char*, int>> metrics;
+  for (const auto& it : metrics_) {
+    const char* metric_name = nullptr;
+    switch (it.first) {
+      case AutofillMetrics::UkmLogger::AUTOFILL_FORM_SUBMITTED_STATE:
+        metric_name =
+            internal::kUKMFormInteractionsAutofillFormSubmittedStateMetricName;
+        break;
+      case AutofillMetrics::UkmLogger::USER_HAPPINESS_METRIC:
+        metric_name =
+            internal::kUKMFormInteractionsUserHappinessMetricMetricName;
+        break;
+      case AutofillMetrics::UkmLogger::ADDRESS_FORM_EVENT:
+        metric_name = internal::kUKMFormInteractionsAddressFormEventMetricName;
+        break;
+      case AutofillMetrics::UkmLogger::CREDIT_CARD_FORM_EVENT:
+        metric_name =
+            internal::kUKMFormInteractionsCreditCardFormEventMetricName;
+        break;
+      case AutofillMetrics::UkmLogger::UNMASK_PROMPT_EVENT:
+        metric_name = internal::kUKMFormInteractionsUnmaskPromptEventMetricName;
+        break;
+      default:
+        NOTREACHED();
+    }
+    metrics.push_back(std::make_pair(metric_name, it.second));
+  }
+  AutofillMetrics::LogUkm(ukm_service_, url_,
+                          internal::kUKMFormInteractionsEntryName, metrics);
+  metrics_.clear();
 }
 
 }  // namespace autofill