[Autofill] Send Autofill upload when active form loses focus.

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 <algorithm>
 #include <limits>
@@ skipping 208 matching lines @@
       autofill_field->Type().GetStorableType() != CREDIT_CARD_NUMBER) {
     return false;
   }
 
   static const int kShowScanCreditCardMaxValueLength = 6;
   return field.value.size() <= kShowScanCreditCardMaxValueLength &&
          base::ContainsOnlyChars(CreditCard::StripSeparators(field.value),
                                  base::ASCIIToUTF16("0123456789"));
 }
 
+void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
+                                  const TimeTicks& timestamp) {
+  if (!IsValidFormDataVector(forms))
+    return;
+
+  if (!driver_->RendererIsAvailable())
+    return;
+
+  bool enabled = IsAutofillEnabled();
+  if (!has_logged_autofill_enabled_) {
+    AutofillMetrics::LogIsAutofillEnabledAtPageLoad(enabled);
+    has_logged_autofill_enabled_ = true;
+  }
+
+  if (!enabled)
+    return;
+
+  for (const FormData& form : forms) {
+    forms_loaded_timestamps_[form] = timestamp;
+  }
+
+  ParseForms(forms);
+}
+
 bool AutofillManager::OnWillSubmitForm(const FormData& form,
                                        const TimeTicks& timestamp) {
   if (!IsValidFormData(form))
     return false;
 
   // We will always give Autocomplete a chance to save the data.
   scoped_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
   if (!submitted_form) {
     autocomplete_history_manager_->OnWillSubmitForm(form);
     return false;
   }
 
   // However, if Autofill has recognized a field as CVC, that shouldn't be
   // saved.
   FormData form_for_autocomplete = submitted_form->ToFormData();
   for (size_t i = 0; i < submitted_form->field_count(); ++i) {
     if (submitted_form->field(i)->Type().GetStorableType() ==
         CREDIT_CARD_VERIFICATION_CODE) {
       form_for_autocomplete.fields[i].should_autocomplete = false;
     }
   }
   autocomplete_history_manager_->OnWillSubmitForm(form_for_autocomplete);
 
   address_form_event_logger_->OnWillSubmitForm();
   credit_card_form_event_logger_->OnWillSubmitForm();
 
+  StartUploadProcess(std::move(submitted_form), timestamp, true);
+
+  return true;
+}
+
+bool AutofillManager::OnFormSubmitted(const FormData& form) {
+  if (!IsValidFormData(form))
+    return false;
+
+  // We will always give Autocomplete a chance to save the data.
+  scoped_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
+  if (!submitted_form) {
+    return false;
+  }
+
+  address_form_event_logger_->OnFormSubmitted();
+  credit_card_form_event_logger_->OnFormSubmitted();
+
+  // Update Personal Data with the form's submitted data.
+  if (submitted_form->IsAutofillable())
+    ImportFormData(*submitted_form);
+
+  recently_unmasked_cards_.clear();
+
+  return true;
+}
+
+void AutofillManager::StartUploadProcess(
+    scoped_ptr<FormStructure> form_structure,
+    const TimeTicks& timestamp,
+    bool observed_submission) {
   // Only upload server statistics and UMA metrics if at least some local data
   // is available to use as a baseline.
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
-  if (submitted_form->IsAutofillable()) {
+  if (observed_submission && form_structure->IsAutofillable()) {
+    // TODO(mathp): provide metrics for non-submission uploads.
     AutofillMetrics::LogNumberOfProfilesAtAutofillableFormSubmission(
         personal_data_->GetProfiles().size());
   }
   const std::vector<CreditCard*>& credit_cards =
       personal_data_->GetCreditCards();
   if (!profiles.empty() || !credit_cards.empty()) {
     // Copy the profile and credit card data, so that it can be accessed on a
     // separate thread.
     std::vector<AutofillProfile> copied_profiles;
     copied_profiles.reserve(profiles.size());
     for (const AutofillProfile* profile : profiles)
       copied_profiles.push_back(*profile);
 
     std::vector<CreditCard> copied_credit_cards;
     copied_credit_cards.reserve(credit_cards.size());
     for (const CreditCard* card : credit_cards)
       copied_credit_cards.push_back(*card);
 
-    // Note that ownership of |submitted_form| is passed to the second task,
+    // Note that ownership of |form_structure| is passed to the second task,
     // using |base::Owned|.
-    FormStructure* raw_submitted_form = submitted_form.get();
+    FormStructure* raw_form = form_structure.get();
+    TimeTicks loaded_timestamp =
+        forms_loaded_timestamps_[raw_form->ToFormData()];
     driver_->GetBlockingPool()->PostTaskAndReply(
         FROM_HERE,
-        base::Bind(&DeterminePossibleFieldTypesForUpload,
-                   copied_profiles,
-                   copied_credit_cards,
-                   app_locale_,
-                   raw_submitted_form),
+        base::Bind(&DeterminePossibleFieldTypesForUpload, copied_profiles,
+                   copied_credit_cards, app_locale_, raw_form),
         base::Bind(&AutofillManager::UploadFormDataAsyncCallback,
                    weak_ptr_factory_.GetWeakPtr(),
-                   base::Owned(submitted_form.release()),
-                   forms_loaded_timestamps_[form],
-                   initial_interaction_timestamp_,
-                   timestamp));
+                   base::Owned(form_structure.release()), loaded_timestamp,
+                   initial_interaction_timestamp_, timestamp,
+                   observed_submission));
   }
-
-  return true;
 }
 
-bool AutofillManager::OnFormSubmitted(const FormData& form) {
-  if (!IsValidFormData(form))
-    return false;
-
-  // We will always give Autocomplete a chance to save the data.
-  scoped_ptr<FormStructure> submitted_form = ValidateSubmittedForm(form);
-  if (!submitted_form) {
-    return false;
+void AutofillManager::UpdatePendingForm(const FormData& form) {
+  // Process the current pending form if different than supplied |form|.
+  if (pending_form_data_ && !pending_form_data_->SameFormAs(form)) {
+    ProcessPendingFormForUpload();
   }
-
-  address_form_event_logger_->OnFormSubmitted();
-  credit_card_form_event_logger_->OnFormSubmitted();
-
-  // Update Personal Data with the form's submitted data.
-  if (submitted_form->IsAutofillable())
-    ImportFormData(*submitted_form);
-
-  recently_unmasked_cards_.clear();
-
-  return true;
+  // A new pending form is assigned.
+  pending_form_data_.reset(new FormData(form));
 }
 
-void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
-                                  const TimeTicks& timestamp) {
-  if (!IsValidFormDataVector(forms))
+void AutofillManager::ProcessPendingFormForUpload() {
+  if (!pending_form_data_)
     return;
 
-  if (!driver_->RendererIsAvailable())
-    return;
+  // We copy |pending_form_data_| to a new FormStructure to be consumed by the
+  // upload process and reset |pending_form_data_|.
+  scoped_ptr<FormStructure> upload_form(new FormStructure(*pending_form_data_));
+  pending_form_data_.reset();
 
-  bool enabled = IsAutofillEnabled();
-  if (!has_logged_autofill_enabled_) {
-    AutofillMetrics::LogIsAutofillEnabledAtPageLoad(enabled);
-    has_logged_autofill_enabled_ = true;
-  }
-
-  if (!enabled)
-    return;
-
-  for (size_t i = 0; i < forms.size(); ++i) {
-    forms_loaded_timestamps_[forms[i]] = timestamp;
-  }
-
-  ParseForms(forms);
+  StartUploadProcess(std::move(upload_form), base::TimeTicks::Now(), false);
 }
 
 void AutofillManager::OnTextFieldDidChange(const FormData& form,
                                            const FormFieldData& field,
                                            const TimeTicks& timestamp) {
   if (!IsValidFormData(form) || !IsValidFormFieldData(field))
     return;
 
   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);
   }
 
   if (autofill_field->is_autofilled) {
     autofill_field->is_autofilled = false;
     autofill_field->set_previously_autofilled(true);
     AutofillMetrics::LogUserHappinessMetric(
         AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD);
@@ skipping 212 matching lines @@
                                          const CreditCard& credit_card) {
   if (!IsValidFormData(form) || !IsValidFormFieldData(field) ||
       !driver_->RendererIsAvailable()) {
     return;
   }
 
   FillOrPreviewDataModelForm(AutofillDriver::FORM_DATA_ACTION_FILL, query_id,
                              form, field, credit_card, true);
 }
 
+void AutofillManager::OnFocusNoLongerOnForm() {
+  ProcessPendingFormForUpload();
+}
+
 void AutofillManager::OnDidPreviewAutofillFormData() {
   if (test_delegate_)
     test_delegate_->DidPreviewFormData();
 }
 
-void AutofillManager::OnDidFillAutofillFormData(const TimeTicks& timestamp) {
+void AutofillManager::OnDidFillAutofillFormData(const FormData& form,
+                                                const TimeTicks& timestamp) {
   if (test_delegate_)
     test_delegate_->DidFillFormData();
 
+  UpdatePendingForm(form);
+
   AutofillMetrics::LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL);
   if (!user_did_autofill_) {
     user_did_autofill_ = true;
     AutofillMetrics::LogUserHappinessMetric(
         AutofillMetrics::USER_DID_AUTOFILL_ONCE);
   }
 
   UpdateInitialInteractionTimestamp(timestamp);
 }
 
@@ skipping 391 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) {
-  submitted_form->LogQualityMetrics(
-      load_time, interaction_time, submission_time, client_->GetRapporService(),
-      did_show_suggestions_);
+    const TimeTicks& submission_time,
+    bool observed_submission) {
+  // TODO(mathp): Have different set of metrics for non-submission uploads.
+  if (observed_submission) {
+    submitted_form->LogQualityMetrics(
+        load_time, interaction_time, submission_time,
+        client_->GetRapporService(), did_show_suggestions_);
+  }
 
+  // TODO(crbug.com/555015): Differentiate non-submission uploads in the
+  // uploaded payload.
   if (submitted_form->ShouldBeCrowdsourced())
     UploadFormData(*submitted_form);
 }
 
 void AutofillManager::UploadFormData(const FormStructure& submitted_form) {
   if (!download_manager_)
     return;
 
   // Check if the form is among the forms that were recently auto-filled.
   bool was_autofilled = false;
@@ skipping 20 matching lines @@
   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 */));
   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;
+  ProcessPendingFormForUpload();
+  DCHECK(!pending_form_data_);
   unmask_request_ = payments::PaymentsClient::UnmaskRequestDetails();
   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,
@@ skipping 422 matching lines @@
 
 void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
   if (forms.empty())
     return;
 
   std::vector<FormStructure*> non_queryable_forms;
   std::vector<FormStructure*> queryable_forms;
   for (const FormData& form : forms) {
     scoped_ptr<FormStructure> form_structure(new FormStructure(form));
     form_structure->ParseFieldTypesFromAutocompleteAttributes();
-
     if (!form_structure->ShouldBeParsed())
       continue;
 
     form_structure->DetermineHeuristicTypes();
 
     // Ownership is transferred to |form_structures_| which maintains it until
     // the manager is Reset() or destroyed. It is safe to use references below
     // as long as receivers don't take ownership.
     form_structures_.push_back(form_structure.Pass());
 
@@ skipping 126 matching lines @@
     if (i > 0)
       fputs("Next oldest form:\n", file);
   }
   fputs("\n", file);
 
   fclose(file);
 }
 #endif  // ENABLE_FORM_DEBUG_DUMP
 
 }  // namespace autofill