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::FormInteractionsUkmLogger* form_interactions_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;
   }
+  form_interactions_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(

[Steven Holte, 2017/04/10 22:42:32]

This appears to be logging a source for every entry, which you probably
shouldn't do.  Instead, you should log the source once and record multiple
entries to it.  Once we switch to having a global source id, we can just stop
adding the source and start using the global one.

[csashi, 2017/04/11 00:40:23]

FWIW, I was following the logging pattern that had been committed prior to my
change.  I can make this change, by keeping the source_id_ in the
FormInteractionsUkmLogger (similar to UkmPageLoadMetricsObserver). However, I
see 3 issues:

1. FormInteractions has a lifetime that is different from both the
CardUploadDecisionMetric and the DeveloperEngagement. CardUploadDecisionMetric
is logged after the user's form interaction is complete and the user has
submitted the form. DeveloperEngagement is logged when the form is parsed - i.e.
even before user has started interacting with the form.

2. DeveloperEngagement is logged for *all* forms, CardUploadDecisionMetric is
logged with URL key from form that is submitted, and FormInteractions is logged
for with URL key from form that user interacts with (usually same as submitted
form).

3. If we adopt this principle of logging the source only once, should we extend
it to UkmPageLoadMetricsObserver also?

I can make the change such that all logging from autofill_manager log the source
just once with some additional state in autofill_manager. Please confirm.

+    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::FormInteractionsUkmLogger* form_interactions_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),
+      form_interactions_ukm_logger_(form_interactions_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_)
+      form_interactions_ukm_logger_->LogCreditCardFormEvent(event);
+    else
+      form_interactions_ukm_logger_->LogAddressFormEvent(event);
+  }
+}
+
+AutofillMetrics::FormInteractionsUkmLogger::FormInteractionsUkmLogger(
+    ukm::UkmService* ukm_service)
+    : ukm_service_(ukm_service) {}
+
+AutofillMetrics::FormInteractionsUkmLogger::~FormInteractionsUkmLogger() {
+  // Submit pending events, if any. If the browser tab starts loading a new page
+  // when the user types a new URL prior to form submission,
+  // |LogAutofillFormSubmittedState| would not be invoked.
+  SubmitUkm();
+}
+
+void AutofillMetrics::FormInteractionsUkmLogger::LogAutofillFormSubmittedState(
+    AutofillFormSubmittedState state) {
+  metrics_.push_back(
+      std::make_pair(AUTOFILL_FORM_SUBMITTED_STATE, static_cast<int>(state)));
+  // User submitted form, we can submit the events for this form.
+  SubmitUkm();
+}
+
+void AutofillMetrics::FormInteractionsUkmLogger::LogUserHappinessMetric(
+    UserHappinessMetric metric) {
+  metrics_.push_back(
+      std::make_pair(USER_HAPPINESS_METRIC, static_cast<int>(metric)));
+}
+
+void AutofillMetrics::FormInteractionsUkmLogger::LogAddressFormEvent(
+    FormEvent event) {
+  metrics_.push_back(
+      std::make_pair(ADDRESS_FORM_EVENT, static_cast<int>(event)));
+}
+
+void AutofillMetrics::FormInteractionsUkmLogger::LogCreditCardFormEvent(
+    FormEvent event) {
+  metrics_.push_back(
+      std::make_pair(CREDIT_CARD_FORM_EVENT, static_cast<int>(event)));
+}
+
+void AutofillMetrics::FormInteractionsUkmLogger::LogUnmaskPromptEvent(
+    UnmaskPromptEvent event) {
+  metrics_.push_back(
+      std::make_pair(UNMASK_PROMPT_EVENT, static_cast<int>(event)));
+}
+
+void AutofillMetrics::FormInteractionsUkmLogger::SubmitUkm() {
+  std::vector<std::pair<const char*, int>> metrics;
+  for (const auto& it : metrics_) {
+    const char* metric_name = nullptr;
+    switch (it.first) {
+      case AutofillMetrics::FormInteractionsUkmLogger::
+          AUTOFILL_FORM_SUBMITTED_STATE:

[Steven Holte, 2017/04/10 22:42:31]

Why store all of this in multiple maps before putting it in UkmEntry?

It seems like it would be much simpler to just store this information in
UkmLogger members, and then just build the Entry from the members?

[csashi, 2017/04/11 00:40:23]

I am not using 'maps' - I have a vector of metrics. The same metric name could
be repeated. For example, we may show a suggestion, the user may edit, then we
show a suggestion again and so on. - we want to capture this 'session'.

In case you were referring to this switch statement as the 'map', I have removed
the switch.

[Steven Holte, 2017/04/11 17:37:57]

If I understand this right, you intending to infer the order of edits and fills
from the order of metrics within an entry?  I don't think we have an intention
to preserve that order during processing of this data.  It may make more sense
for you to send separate entries for each of your events and have something to
order them by, either a timestamp or a counter. (though you can still batch them
if they are only important for the context of the next event).

E.g. for some form, you might record
AutofillEvent {
  FormType: #CreditCard
  EventCounter: 0
  HadTypedData: 0
}
AutofillEvent {
  FormType: #CreditCard
  EventCounter: 1
  HadEdits: 1
}
AutofillSubmitEvent {
  FormType: #CreditCard
  EventCounter: 2
  HadEdits: 1
}

[csashi, 2017/04/12 00:13:53]

Done.

Your understanding is correct. I was intending to infer the order of events from
the order of the metrics. If we don't intend to preserve the order, it may be
worthwhile to document that explicitly because
https://developers.google.com/protocol-buffers/docs/encoding#optional says:
"""
The order of the elements with respect to each other is preserved when parsing,
though the ordering with respect to other fields is lost.
"""

+        metric_name =
+            internal::kUKMFormInteractionsAutofillFormSubmittedStateMetricName;
+        break;
+      case AutofillMetrics::FormInteractionsUkmLogger::USER_HAPPINESS_METRIC:
+        metric_name =
+            internal::kUKMFormInteractionsUserHappinessMetricMetricName;
+        break;
+      case AutofillMetrics::FormInteractionsUkmLogger::ADDRESS_FORM_EVENT:
+        metric_name = internal::kUKMFormInteractionsAddressFormEventMetricName;
+        break;
+      case AutofillMetrics::FormInteractionsUkmLogger::CREDIT_CARD_FORM_EVENT:
+        metric_name =
+            internal::kUKMFormInteractionsCreditCardFormEventMetricName;
+        break;
+      case AutofillMetrics::FormInteractionsUkmLogger::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