Fix sending autofill votes for sign-in forms.

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 "components/autofill/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 316 matching lines @@
   }
 
   // Verify that the last queried forms equal |expected_forms|.
   void VerifyLastQueriedForms(const std::vector<FormData>& expected_forms) {
     ASSERT_EQ(expected_forms.size(), last_queried_forms_.size());
     for (size_t i = 0; i < expected_forms.size(); ++i) {
       EXPECT_EQ(*last_queried_forms_[i], expected_forms[i]);
     }
   }
 
+  MOCK_METHOD5(StartUploadRequest,
+               bool(const FormStructure&,
+                    bool,
+                    const ServerFieldTypeSet&,
+                    const std::string&,
+                    bool));
+
  private:
   std::vector<FormStructure*> last_queried_forms_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillDownloadManager);
 };
 
 void ExpectFilledField(const char* expected_label,
                        const char* expected_name,
                        const char* expected_value,
                        const char* expected_form_control_type,
@@ skipping 184 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_(false),
         credit_card_was_uploaded_(false),
-        expected_observed_submission_(true) {
+        expected_observed_submission_(true),
+        call_parent_upload_form_data_(false) {
     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;
   }
@@ skipping 10 matching lines @@
 
   void set_expected_submitted_field_types(
       const std::vector<ServerFieldTypeSet>& expected_types) {
     expected_submitted_field_types_ = expected_types;
   }
 
   void set_expected_observed_submission(bool expected) {
     expected_observed_submission_ = expected;
   }
 
+  void set_call_parent_upload_form_data(bool value) {
+    call_parent_upload_form_data_ = value;
+  }
+
   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.
@@ skipping 26 matching lines @@
   // 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 calls within StartUploadProcess() to complete.
   void WaitForAsyncUploadProcess() { run_loop_->Run(); }
 
   void UploadFormData(const FormStructure& submitted_form,
                       bool observed_submission) override {
     submitted_form_signature_ = submitted_form.FormSignatureAsStr();
+
+    if (call_parent_upload_form_data_)
+      AutofillManager::UploadFormData(submitted_form, observed_submission);
   }
 
   const std::string GetSubmittedFormSignature() {
     return submitted_form_signature_;
   }
 
   AutofillProfile* GetProfileWithGUID(const char* guid) {
     return personal_data_->GetProfileWithGUID(guid);
   }
 
@@ skipping 29 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 expected_observed_submission_;
+  bool call_parent_upload_form_data_;
 
   std::unique_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 5387 matching lines @@
   test::CreateTestFormField("Password", "pw", "secret", "password", &field);
   form.fields.push_back(field);
   types.clear();
   types.insert(PASSWORD);
   expected_types.push_back(types);
 
   // 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(true);
+  autofill_manager_->set_call_parent_upload_form_data(true);
   autofill_manager_->ResetRunLoop();
 
   std::unique_ptr<FormStructure> form_structure(new FormStructure(form));
   form_structure->set_is_signin_upload(true);
   form_structure->field(1)->set_possible_types({autofill::PASSWORD});
 
   std::string signature = form_structure->FormSignatureAsStr();
+
+  ServerFieldTypeSet uploaded_available_types;
+  EXPECT_CALL(*download_manager_,
+              StartUploadRequest(_, false, _, std::string(), true))
+      .WillOnce(DoAll(SaveArg<2>(&uploaded_available_types), Return(true)));
   autofill_manager_->StartUploadProcess(std::move(form_structure),
                                         base::TimeTicks::Now(), true);
 
   // Wait for upload to complete (will check expected types as well).
   autofill_manager_->WaitForAsyncUploadProcess();
 
   EXPECT_EQ(signature, autofill_manager_->GetSubmittedFormSignature());
+  EXPECT_NE(uploaded_available_types.end(),
+            uploaded_available_types.find(autofill::PASSWORD));
 }
 
 }  // namespace autofill