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

components/autofill/core/browser/autofill_manager_unittest.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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 453 matching lines @@
 class TestAutofillManager : public AutofillManager {
  public:
   TestAutofillManager(AutofillDriver* driver,
                       AutofillClient* client,
                       TestPersonalDataManager* personal_data)
       : AutofillManager(driver, client, personal_data),
         personal_data_(personal_data),
         autofill_enabled_(true),
         credit_card_upload_enabled_(true),
         credit_card_was_uploaded_(false),
-        expect_all_unknown_possible_types_(false) {
+        expect_all_unknown_possible_types_(false),
+        expected_observed_submission_(true) {
     set_payments_client(
         new TestPaymentsClient(driver->GetURLRequestContext(), this));
   }
   ~TestAutofillManager() override {}
 
   bool IsAutofillEnabled() const override { return autofill_enabled_; }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
   bool IsCreditCardUploadEnabled() override {
     return credit_card_upload_enabled_;
   }
 
   void set_credit_card_upload_enabled(bool credit_card_upload_enabled) {
     credit_card_upload_enabled_ = credit_card_upload_enabled;
   }
 
   bool credit_card_was_uploaded() { return credit_card_was_uploaded_; }
 
   void set_expected_submitted_field_types(
       const std::vector<ServerFieldTypeSet>& expected_types) {
     expected_submitted_field_types_ = expected_types;
   }
 
-  void UploadFormDataAsyncCallback(
-      const FormStructure* submitted_form,
-      const base::TimeTicks& load_time,
-      const base::TimeTicks& interaction_time,
-      const base::TimeTicks& submission_time) override {
+  void set_expected_observed_submission(bool expected) {
+    expected_observed_submission_ = expected;
+  }
+
+  void UploadFormDataAsyncCallback(const FormStructure* submitted_form,
+                                   const base::TimeTicks& load_time,
+                                   const base::TimeTicks& interaction_time,
+                                   const base::TimeTicks& submission_time,
+                                   bool observed_submission) override {
     run_loop_->Quit();
 
+    EXPECT_EQ(expected_observed_submission_, observed_submission);
+
     // If we have expected field types set, make sure they match.
     if (!expected_submitted_field_types_.empty()) {
       ASSERT_EQ(expected_submitted_field_types_.size(),
                 submitted_form->field_count());
       for (size_t i = 0; i < expected_submitted_field_types_.size(); ++i) {
         SCOPED_TRACE(
             base::StringPrintf(
                 "Field %d with value %s", static_cast<int>(i),
                 base::UTF16ToUTF8(submitted_form->field(i)->value).c_str()));
         const ServerFieldTypeSet& possible_types =
             submitted_form->field(i)->possible_types();
         EXPECT_EQ(expected_submitted_field_types_[i].size(),
                   possible_types.size());
         for (ServerFieldTypeSet::const_iterator it =
                  expected_submitted_field_types_[i].begin();
              it != expected_submitted_field_types_[i].end(); ++it) {
           EXPECT_TRUE(possible_types.count(*it))
               << "Expected type: " << AutofillType(*it).ToString();
         }
       }
     }
 
-    AutofillManager::UploadFormDataAsyncCallback(submitted_form,
-                                                 load_time,
-                                                 interaction_time,
-                                                 submission_time);
+    AutofillManager::UploadFormDataAsyncCallback(
+        submitted_form, load_time, interaction_time, submission_time,
+        observed_submission);
   }
 
   // Resets the run loop so that it can wait for an asynchronous form
   // submission to complete.
   void ResetRunLoop() { run_loop_.reset(new base::RunLoop()); }
 
-  // Wait for the asynchronous OnWillSubmitForm() call to complete.
-  void WaitForAsyncOnWillSubmitForm() { run_loop_->Run(); }
+  // Wait for the asynchronous calls within StartUploadProcess() to complete.
+  void WaitForAsyncUploadProcess() { run_loop_->Run(); }
 
   void UploadFormData(const FormStructure& submitted_form) override {
     submitted_form_signature_ = submitted_form.FormSignature();
   }
 
   const std::string GetSubmittedFormSignature() {
     return submitted_form_signature_;
   }
 
   AutofillProfile* GetProfileWithGUID(const char* guid) {
@@ skipping 32 matching lines @@
     credit_card_was_uploaded_ = true;
   };
 
   // Weak reference.
   TestPersonalDataManager* personal_data_;
 
   bool autofill_enabled_;
   bool credit_card_upload_enabled_;
   bool credit_card_was_uploaded_;
   bool expect_all_unknown_possible_types_;
+  bool expected_observed_submission_;
 
   scoped_ptr<base::RunLoop> run_loop_;
 
   std::string submitted_form_signature_;
   std::vector<ServerFieldTypeSet> expected_submitted_field_types_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
 class TestAutofillExternalDelegate : public AutofillExternalDelegate {
@@ skipping 148 matching lines @@
     autofill_manager_->autocomplete_history_manager_->SendSuggestions(&result);
   }
 
   void FormsSeen(const std::vector<FormData>& forms) {
     autofill_manager_->OnFormsSeen(forms, base::TimeTicks());
   }
 
   void FormSubmitted(const FormData& form) {
     autofill_manager_->ResetRunLoop();
     if (autofill_manager_->OnWillSubmitForm(form, base::TimeTicks::Now()))
-      autofill_manager_->WaitForAsyncOnWillSubmitForm();
+      autofill_manager_->WaitForAsyncUploadProcess();
     autofill_manager_->OnFormSubmitted(form);
   }
 
   void FillAutofillFormData(int query_id,
                             const FormData& form,
                             const FormFieldData& field,
                             int unique_id) {
     autofill_manager_->FillOrPreviewForm(
         AutofillDriver::FORM_DATA_ACTION_FILL, query_id, form, field,
         unique_id);
@@ skipping 1710 matching lines @@
                                      MakeFrontendID(std::string(), guid),
                                      &response_page_id, &response_data);
   ExpectFilledAddressFormElvis(response_page_id, response_data, kDefaultPageID,
                                false);
 
   // Simulate OnWillSubmitForm(). We should *not* be calling into the PDM at
   // this point (since the form was not submitted). Does not call
   // OnFormSubmitted.
   autofill_manager_->ResetRunLoop();
   autofill_manager_->OnWillSubmitForm(response_data, base::TimeTicks::Now());
-  autofill_manager_->WaitForAsyncOnWillSubmitForm();
+  autofill_manager_->WaitForAsyncUploadProcess();
   EXPECT_EQ(0, personal_data_.num_times_save_imported_profile_called());
 }
 
 // Test that when Autocomplete is enabled and Autofill is disabled, form
 // submissions are still received by AutocompleteHistoryManager.
 TEST_F(AutofillManagerTest, FormSubmittedAutocompleteEnabled) {
   TestAutofillClient client;
   autofill_manager_.reset(
       new TestAutofillManager(autofill_driver_.get(), &client, NULL));
   autofill_manager_->set_autofill_enabled(false);
@@ skipping 838 matching lines @@
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   EXPECT_TRUE(external_delegate_->on_query_seen());
 }
 
+// Test that unfocusing a filled form sends an upload with types matching the
+// fields.
+TEST_F(AutofillManagerTest, OnTextFieldDidChangeAndUnfocus_Upload) {
+  // Set up our form data (it's already filled out with user data).
+  FormData form;
+  form.name = ASCIIToUTF16("MyForm");
+  form.origin = GURL("http://myform.com/form.html");
+  form.action = GURL("http://myform.com/submit.html");
+
+  std::vector<ServerFieldTypeSet> expected_types;
+  ServerFieldTypeSet types;
+
+  FormFieldData field;
+  test::CreateTestFormField("First Name", "firstname", "Elvis", "text", &field);
+  form.fields.push_back(field);
+  types.insert(NAME_FIRST);
+  expected_types.push_back(types);
+
+  test::CreateTestFormField("Last Name", "lastname", "Presley", "text", &field);
+  form.fields.push_back(field);
+  types.clear();
+  types.insert(NAME_LAST);
+  expected_types.push_back(types);
+
+  test::CreateTestFormField("Email", "email", "theking@gmail.com", "text",
+                            &field);
+  form.fields.push_back(field);
+  types.clear();
+  types.insert(EMAIL_ADDRESS);
+  expected_types.push_back(types);
+
+  FormsSeen(std::vector<FormData>(1, form));
+
+  // We will expect these types in the upload and no observed submission (the
+  // callback initiated by WaitForAsyncUploadProcess checks these expectations.)
+  autofill_manager_->set_expected_submitted_field_types(expected_types);
+  autofill_manager_->set_expected_observed_submission(false);
+
+  // Simulate editing a field.
+  autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
+                                          base::TimeTicks::Now());
+
+  autofill_manager_->ResetRunLoop();
+  // Simulate lost of focus on the form.
+  autofill_manager_->OnFocusNoLongerOnForm();
+  // Wait for upload to complete (will check expected types as well).
+  autofill_manager_->WaitForAsyncUploadProcess();
+}
+
+// Test that navigating with a filled form sends an upload with types matching
+// the fields.
+TEST_F(AutofillManagerTest, OnTextFieldDidChangeAndNavigation_Upload) {
+  // Set up our form data (it's already filled out with user data).
+  FormData form;
+  form.name = ASCIIToUTF16("MyForm");
+  form.origin = GURL("http://myform.com/form.html");
+  form.action = GURL("http://myform.com/submit.html");
+
+  std::vector<ServerFieldTypeSet> expected_types;
+  ServerFieldTypeSet types;
+
+  FormFieldData field;
+  test::CreateTestFormField("First Name", "firstname", "Elvis", "text", &field);
+  form.fields.push_back(field);
+  types.insert(NAME_FIRST);
+  expected_types.push_back(types);
+
+  test::CreateTestFormField("Last Name", "lastname", "Presley", "text", &field);
+  form.fields.push_back(field);
+  types.clear();
+  types.insert(NAME_LAST);
+  expected_types.push_back(types);
+
+  test::CreateTestFormField("Email", "email", "theking@gmail.com", "text",
+                            &field);
+  form.fields.push_back(field);
+  types.clear();
+  types.insert(EMAIL_ADDRESS);
+  expected_types.push_back(types);
+
+  FormsSeen(std::vector<FormData>(1, form));
+
+  // We will expect these types in the upload and no observed submission. (the
+  // callback initiated by WaitForAsyncUploadProcess checks these expectations.)
+  autofill_manager_->set_expected_submitted_field_types(expected_types);
+  autofill_manager_->set_expected_observed_submission(false);
+
+  // Simulate editing a field.
+  autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
+                                          base::TimeTicks::Now());
+
+  autofill_manager_->ResetRunLoop();
+  // Simulate a navigation so that the pending form is uploaded.
+  autofill_manager_->Reset();
+  // Wait for upload to complete (will check expected types as well).
+  autofill_manager_->WaitForAsyncUploadProcess();
+}
+
+// Test that unfocusing a filled form sends an upload with types matching the
+// fields.
+TEST_F(AutofillManagerTest, OnDidFillAutofillFormDataAndUnfocus_Upload) {
+  // Set up our form data (empty).
+  FormData form;
+  form.name = ASCIIToUTF16("MyForm");
+  form.origin = GURL("http://myform.com/form.html");
+  form.action = GURL("http://myform.com/submit.html");
+
+  std::vector<ServerFieldTypeSet> expected_types;
+
+  // These fields should all match.
+  ServerFieldTypeSet types;
+  FormFieldData field;
+  test::CreateTestFormField("First Name", "firstname", "", "text", &field);
+  form.fields.push_back(field);
+  types.insert(NAME_FIRST);
+  expected_types.push_back(types);
+
+  test::CreateTestFormField("Last Name", "lastname", "", "text", &field);
+  form.fields.push_back(field);
+  types.clear();
+  types.insert(NAME_LAST);
+  expected_types.push_back(types);
+
+  test::CreateTestFormField("Email", "email", "", "text", &field);
+  form.fields.push_back(field);
+  types.clear();
+  types.insert(EMAIL_ADDRESS);
+  expected_types.push_back(types);
+
+  FormsSeen(std::vector<FormData>(1, form));
+
+  // We will expect these types in the upload and no observed submission. (the
+  // callback initiated by WaitForAsyncUploadProcess checks these expectations.)
+  autofill_manager_->set_expected_submitted_field_types(expected_types);
+  autofill_manager_->set_expected_observed_submission(false);
+
+  // Form was autofilled with user data.
+  form.fields[0].value = base::ASCIIToUTF16("Elvis");
+  form.fields[1].value = base::ASCIIToUTF16("Presley");
+  form.fields[2].value = base::ASCIIToUTF16("theking@gmail.com");
+  autofill_manager_->OnDidFillAutofillFormData(form, base::TimeTicks::Now());
+
+  autofill_manager_->ResetRunLoop();
+  // Simulate lost of focus on the form.
+  autofill_manager_->OnFocusNoLongerOnForm();
+  // Wait for upload to complete.
+  autofill_manager_->WaitForAsyncUploadProcess();
+}
+
 // Test to verify suggestions appears for forms having credit card number split
 // across fields.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestionsForNumberSpitAcrossFields) {
   // Set up our form data with credit card number split across fields.
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
   form.origin = GURL("https://myform.com/form.html");
   form.action = GURL("https://myform.com/submit.html");
 
   FormFieldData name_field;
@@ skipping 502 matching lines @@
   // Make sure it's reset for the next test case.
   autofill_driver_->SetIsOffTheRecord(false);
   EXPECT_TRUE(autofill_manager_->ShouldUploadForm(form_structure_4));
 
   // Autofill disabled.
   autofill_manager_->set_autofill_enabled(false);
   EXPECT_FALSE(autofill_manager_->ShouldUploadForm(form_structure_3));
 }
 
 }  // namespace autofill