UKM that threads together multiple form interaction events.

components/autofill/core/browser/autofill_manager.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 <stdint.h>
 
 #include <algorithm>
@@ skipping 199 matching lines @@
 
 }  // namespace
 
 AutofillManager::AutofillManager(
     AutofillDriver* driver,
     AutofillClient* client,
     const std::string& app_locale,
     AutofillDownloadManagerState enable_download_manager)
     : driver_(driver),
       client_(client),
-      payments_client_(
-          new payments::PaymentsClient(driver->GetURLRequestContext(), this)),
+      payments_client_(base::MakeUnique<payments::PaymentsClient>(
+          driver->GetURLRequestContext(),
+          this)),
       app_locale_(app_locale),
       personal_data_(client->GetPersonalDataManager()),
       autocomplete_history_manager_(
-          new AutocompleteHistoryManager(driver, client)),
+          base::MakeUnique<AutocompleteHistoryManager>(driver, client)),
+      ukm_logger_(base::MakeUnique<AutofillMetrics::UkmLogger>(
+          client->GetUkmService())),
       address_form_event_logger_(
-          new AutofillMetrics::FormEventLogger(false /* is_for_credit_card */)),
+          base::MakeUnique<AutofillMetrics::FormEventLogger>(
+              false /* is_for_credit_card */,
+              ukm_logger_.get())),
       credit_card_form_event_logger_(
-          new AutofillMetrics::FormEventLogger(true /* is_for_credit_card */)),
+          base::MakeUnique<AutofillMetrics::FormEventLogger>(
+              true /* is_for_credit_card */,
+              ukm_logger_.get())),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       user_did_accept_upload_prompt_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
 #if defined(OS_ANDROID) || defined(OS_IOS)
@@ skipping 268 matching lines @@
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (!GetCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   UpdatePendingForm(form);
 
   if (!user_did_type_) {
     user_did_type_ = true;
     AutofillMetrics::LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE);
+    ukm_logger_->LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE);
   }
 
   if (autofill_field->is_autofilled) {
     autofill_field->is_autofilled = false;
     autofill_field->set_previously_autofilled(true);
     AutofillMetrics::LogUserHappinessMetric(
         AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD);
+    ukm_logger_->LogUserHappinessMetric(
+        AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD);
 
     if (!user_did_edit_autofilled_field_) {
       user_did_edit_autofilled_field_ = true;
       AutofillMetrics::LogUserHappinessMetric(
           AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD_ONCE);
     }
   }
 
   UpdateInitialInteractionTimestamp(timestamp);
 }
@@ skipping 271 matching lines @@
 }
 
 void AutofillManager::OnDidFillAutofillFormData(const FormData& form,
                                                 const TimeTicks& timestamp) {
   if (test_delegate_)
     test_delegate_->DidFillFormData();
 
   UpdatePendingForm(form);
 
   AutofillMetrics::LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL);
+  ukm_logger_->LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL);
   if (!user_did_autofill_) {
     user_did_autofill_ = true;
     AutofillMetrics::LogUserHappinessMetric(
         AutofillMetrics::USER_DID_AUTOFILL_ONCE);
   }
 
   UpdateInitialInteractionTimestamp(timestamp);
 }
 
 void AutofillManager::DidShowSuggestions(bool is_new_popup,
@@ skipping 255 matching lines @@
 
 void AutofillManager::OnFullCardRequestFailed() {
   driver_->RendererShouldClearPreviewedForm();
 }
 
 void AutofillManager::ShowUnmaskPrompt(
     const CreditCard& card,
     AutofillClient::UnmaskCardReason reason,
     base::WeakPtr<CardUnmaskDelegate> delegate) {
   client_->ShowUnmaskPrompt(card, reason, delegate);
+  ukm_logger_->LogUnmaskPromptEvent(AutofillMetrics::UNMASK_PROMPT_SHOWN);
 }
 
 void AutofillManager::OnUnmaskVerificationResult(
     AutofillClient::PaymentsRpcResult result) {
   client_->OnUnmaskVerificationResult(result);
 }
 
 void AutofillManager::OnUserDidAcceptUpload() {
   user_did_accept_upload_prompt_ = true;
   if (!upload_request_.risk_data.empty()) {
@@ skipping 270 matching lines @@
 // Note that |submitted_form| is passed as a pointer rather than as a reference
 // so that we can get memory management right across threads.  Note also that we
 // explicitly pass in all the time stamps of interest, as the cached ones might
 // get reset before this method executes.
 void AutofillManager::UploadFormDataAsyncCallback(
     const FormStructure* submitted_form,
     const TimeTicks& load_time,
     const TimeTicks& interaction_time,
     const TimeTicks& submission_time,
     bool observed_submission) {
-  submitted_form->LogQualityMetrics(load_time, interaction_time,
-                                    submission_time,
-                                    client_->GetRapporServiceImpl(),
-                                    did_show_suggestions_, observed_submission);
+  AutofillMetrics::AutofillFormSubmittedState state =
+      submitted_form->LogQualityMetrics(
+          load_time, interaction_time, submission_time,
+          client_->GetRapporServiceImpl(), did_show_suggestions_,
+          observed_submission);
+  if (state < AutofillMetrics::AUTOFILL_FORM_SUBMITTED_STATE_ENUM_SIZE) {

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

Do we expect that this is ever bigger than max? If not, I would put a DCHECK
instead.

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

Done.

+    if (ukm_logger_->url() != submitted_form->source_url())
+      ukm_logger_->set_url(submitted_form->source_url());
+    AutofillMetrics::LogAutofillFormSubmittedState(state, ukm_logger_.get());
+  }
 
   if (submitted_form->ShouldBeCrowdsourced())
     UploadFormData(*submitted_form, observed_submission);
 }
 
 void AutofillManager::UploadFormData(const FormStructure& submitted_form,
                                      bool observed_submission) {
   if (!download_manager_)
     return;
 
@@ skipping 14 matching lines @@
       submitted_form, was_autofilled, non_empty_types,
       std::string() /* login_form_signature */, observed_submission);
 }
 
 void AutofillManager::Reset() {
   // Note that upload_request_ is not reset here because the prompt to
   // save a card is shown after page navigation.
   ProcessPendingFormForUpload();
   DCHECK(!pending_form_data_);
   form_structures_.clear();
-  address_form_event_logger_.reset(
-      new AutofillMetrics::FormEventLogger(false /* is_for_credit_card */));
-  credit_card_form_event_logger_.reset(
-      new AutofillMetrics::FormEventLogger(true /* is_for_credit_card */));
+  ukm_logger_.reset(new AutofillMetrics::UkmLogger(client_->GetUkmService()));
+  address_form_event_logger_.reset(new AutofillMetrics::FormEventLogger(
+      false /* is_for_credit_card */, ukm_logger_.get()));
+  credit_card_form_event_logger_.reset(new AutofillMetrics::FormEventLogger(
+      true /* is_for_credit_card */, ukm_logger_.get()));
 #if defined(OS_ANDROID) || defined(OS_IOS)
   autofill_assistant_.Reset();
 #endif
   has_logged_autofill_enabled_ = false;
   has_logged_address_suggestions_count_ = false;
   did_show_suggestions_ = false;
   user_did_type_ = false;
   user_did_autofill_ = false;
   user_did_edit_autofilled_field_ = false;
   masked_card_ = CreditCard();
   unmasking_query_id_ = -1;
   unmasking_form_ = FormData();
   unmasking_field_ = FormFieldData();
   forms_loaded_timestamps_.clear();
   initial_interaction_timestamp_ = TimeTicks();
   external_delegate_->Reset();
 }
 
 AutofillManager::AutofillManager(AutofillDriver* driver,
                                  AutofillClient* client,
                                  PersonalDataManager* personal_data)
     : driver_(driver),
       client_(client),
-      payments_client_(
-          new payments::PaymentsClient(driver->GetURLRequestContext(), this)),
+      payments_client_(base::MakeUnique<payments::PaymentsClient>(
+          driver->GetURLRequestContext(),
+          this)),
       app_locale_("en-US"),
       personal_data_(personal_data),
       autocomplete_history_manager_(
-          new AutocompleteHistoryManager(driver, client)),
+          base::MakeUnique<AutocompleteHistoryManager>(driver, client)),
+      ukm_logger_(base::MakeUnique<AutofillMetrics::UkmLogger>(
+          client->GetUkmService())),
       address_form_event_logger_(
-          new AutofillMetrics::FormEventLogger(false /* is_for_credit_card */)),
+          base::MakeUnique<AutofillMetrics::FormEventLogger>(
+              false /* is_for_credit_card */,
+              ukm_logger_.get())),
       credit_card_form_event_logger_(
-          new AutofillMetrics::FormEventLogger(true /* is_for_credit_card */)),
+          base::MakeUnique<AutofillMetrics::FormEventLogger>(
+              true /* is_for_credit_card */,
+              ukm_logger_.get())),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       unmasking_query_id_(-1),
       external_delegate_(NULL),
       test_delegate_(NULL),
 #if defined(OS_ANDROID) || defined(OS_IOS)
@@ skipping 206 matching lines @@
   // Note that this may invalidate |data_model|, particularly if it is a Mac
   // address book entry.
   if (action == AutofillDriver::FORM_DATA_ACTION_FILL)
     personal_data_->RecordUseOf(data_model);
 
   driver_->SendFormDataToRenderer(query_id, action, result);
 }
 
 std::unique_ptr<FormStructure> AutofillManager::ValidateSubmittedForm(
     const FormData& form) {
-  std::unique_ptr<FormStructure> submitted_form(new FormStructure(form));
+  std::unique_ptr<FormStructure> submitted_form(
+      base::MakeUnique<FormStructure>(form));
   if (!ShouldUploadForm(*submitted_form))
     return std::unique_ptr<FormStructure>();
 
   // Ignore forms not present in our cache.  These are typically forms with
   // wonky JavaScript that also makes them not auto-fillable.
   FormStructure* cached_submitted_form;
   if (!FindCachedForm(form, &cached_submitted_form))
     return std::unique_ptr<FormStructure>();
 
   submitted_form->UpdateFromCache(*cached_submitted_form, false);
@@ skipping 180 matching lines @@
                                         parse_form_start_time);
   }
 
   if (!queryable_forms.empty() && download_manager_) {
     // Query the server if at least one of the forms was parsed.
     download_manager_->StartQueryRequest(queryable_forms);
   }
 
   if (!queryable_forms.empty() || !non_queryable_forms.empty()) {
     AutofillMetrics::LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED);
+
+    // Log pending events, if any.
+    ukm_logger_->LogUkm();
+
+    // If user submits a form later, we set the key to the |submitted_form|'s

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

I would reformulate to something like, setup the url for the future metrics for
this form.

WDYT?

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

Done.

+    // |source_url()|.
+    ukm_logger_->set_url(forms[0].origin);
+    ukm_logger_->LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED);
 #if defined(OS_IOS)
     // Log this from same location as AutofillMetrics::FORMS_LOADED to ensure
     // that KeyboardAccessoryButtonsIOS and UserHappiness UMA metrics will be
     // directly comparable.
     KeyboardAccessoryMetricsLogger::OnFormsLoaded();
 #endif
   }
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
   // When a credit card form is parsed and conditions are met, show an infobar
@@ skipping 305 matching lines @@
 }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 void AutofillManager::LogCardUploadDecisionUkm(
     AutofillMetrics::CardUploadDecisionMetric upload_decision) {
   AutofillMetrics::LogCardUploadDecisionUkm(
       client_->GetUkmService(), pending_upload_request_url_, upload_decision);
 }
 
 }  // namespace autofill