[Password Generation] Don't send generation vote if the vote is uploaded for another form

components/password_manager/core/browser/password_form_manager_unittest.cc

 // Copyright (c) 2012 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/password_manager/core/browser/password_form_manager.h"
 
 #include <map>
 #include <memory>
 #include <set>
 #include <utility>
@@ skipping 88 matching lines @@
 };
 
 MATCHER_P(CheckUsername, username_value, "Username incorrect") {
   return arg.username_value == username_value;
 }
 
 MATCHER_P(CheckUsernamePtr, username_value, "Username incorrect") {
   return arg && arg->username_value == username_value;
 }
 
-MATCHER_P2(CheckUploadedAutofillTypesAndSignature,
+MATCHER_P3(CheckUploadedAutofillTypesAndSignature,
            form_signature,
            expected_types,
+           expect_generation_vote,
            "Unexpected autofill types or form signature") {
   if (form_signature != arg.FormSignatureAsStr()) {
     // Unexpected form's signature.
     ADD_FAILURE() << "Expected form signature is " << form_signature
                   << ", but found " << arg.FormSignatureAsStr();
     return false;
   }
+  bool found_generation_vote = false;
   for (const auto& field : arg) {
     if (field->possible_types().size() > 1) {
       ADD_FAILURE() << field->name << " field has several possible types";
       return false;
     }
 
+    found_generation_vote |=
+        field->generation_type() !=
+        autofill::AutofillUploadContents::Field::NO_GENERATION;
+
     autofill::ServerFieldType expected_vote =
         expected_types.find(field->name) == expected_types.end()
             ? autofill::NO_SERVER_DATA
             : expected_types.find(field->name)->second;
     autofill::ServerFieldType actual_vote =
         field->possible_types().empty() ? autofill::NO_SERVER_DATA
                                         : *field->possible_types().begin();
     if (expected_vote != actual_vote) {
       ADD_FAILURE() << field->name << " field: expected vote " << expected_vote
                     << ", but found " << actual_vote;
       return false;
     }
   }
+  EXPECT_EQ(expect_generation_vote, found_generation_vote);
   return true;
 }
 
 MATCHER_P2(CheckUploadedGenerationTypesAndSignature,
            form_signature,
            expected_generation_types,
            "Unexpected generation types or form signature") {
   if (form_signature != arg.FormSignatureAsStr()) {
     // Unexpected form's signature.
     ADD_FAILURE() << "Expected form signature is " << form_signature
@@ skipping 256 matching lines @@
 
     // When we're voting for an account creation form, we should also vote
     // for its username field.
     if (field_type && *field_type == autofill::ACCOUNT_CREATION_PASSWORD) {
       expected_types[match.username_element] = autofill::USERNAME;
       expected_available_field_types.insert(autofill::USERNAME);
     } else {
       expected_types[match.username_element] = autofill::UNKNOWN_TYPE;
     }
 
+    bool expect_generation_vote = false;
     if (field_type) {
+      // Show the password generation popup to check that the generation vote
+      // would be ignored.
+      form_manager.set_generation_element(saved_match()->password_element);
+      form_manager.set_generation_popup_was_shown(true);
+      expect_generation_vote =
+          *field_type != autofill::ACCOUNT_CREATION_PASSWORD;
+
       expected_available_field_types.insert(*field_type);
       expected_types[saved_match()->password_element] = *field_type;
-    } else {
-      expected_available_field_types.insert(
-          autofill::NOT_ACCOUNT_CREATION_PASSWORD);
-      expected_types[saved_match()->password_element] =
-          autofill::NOT_ACCOUNT_CREATION_PASSWORD;
     }
 
     if (field_type) {
-      EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
-                  StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
-                                         pending_structure.FormSignatureAsStr(),
-                                         expected_types),
-                                     false, expected_available_field_types,
-                                     expected_login_signature, true));
+      EXPECT_CALL(
+          *client()->mock_driver()->mock_autofill_download_manager(),
+          StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
+                                 pending_structure.FormSignatureAsStr(),
+                                 expected_types, expect_generation_vote),
+                             false, expected_available_field_types,
+                             expected_login_signature, true));
     } else {
       EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
                   StartUploadRequest(_, _, _, _, _))
           .Times(0);
     }
     form_manager.ProvisionallySave(
         form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
     form_manager.Save();
     Mock::VerifyAndClearExpectations(
         client()->mock_driver()->mock_autofill_download_manager());
@@ skipping 76 matching lines @@
         autofill::FormStructure(observed_form()->form_data)
             .FormSignatureAsStr();
 
     std::string expected_login_signature;
     if (field_type == autofill::NEW_PASSWORD) {
       autofill::FormStructure pending_structure(saved_match()->form_data);
       expected_login_signature = pending_structure.FormSignatureAsStr();
     }
     EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
                 StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
-                                       observed_form_signature, expected_types),
+                                       observed_form_signature, expected_types,
+                                       false /* expect_generation_vote */),
                                    false, expected_available_field_types,
                                    expected_login_signature, true));
 
     switch (field_type) {
       case autofill::NEW_PASSWORD:
         form_manager.Update(*saved_match());
         break;
       case autofill::PROBABLY_NEW_PASSWORD:
         form_manager.OnNoInteraction(true /* it is an update */);
         break;
@@ skipping 2027 matching lines @@
   expected_available_field_types.insert(autofill::NEW_PASSWORD);
 
   std::string observed_form_signature =
       autofill::FormStructure(observed_form()->form_data).FormSignatureAsStr();
 
   std::string expected_login_signature =
       autofill::FormStructure(saved_match()->form_data).FormSignatureAsStr();
 
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
-                                     observed_form_signature, expected_types),
+                                     observed_form_signature, expected_types,
+                                     false /* expect_generation_vote */),
                                  false, expected_available_field_types,
                                  expected_login_signature, true));
 
   form_manager.Update(*saved_match());
 }
 
 // Checks uploading a vote about the usage of the password generation popup.
 TEST_F(PasswordFormManagerTest, GeneratedVoteUpload) {
   bool kFalseTrue[] = {false, true};
   SavePromptInteraction kSavePromptInterations[] = {SAVE, NEVER,
@@ skipping 183 matching lines @@
   expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE;
   expected_types[saved_match()->username_element] = autofill::UNKNOWN_TYPE;
   expected_available_field_types.insert(
       autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD);
   expected_types[saved_match()->password_element] =
       autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD;
 
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(
                   CheckUploadedAutofillTypesAndSignature(
-                      pending_structure.FormSignatureAsStr(), expected_types),
+                      pending_structure.FormSignatureAsStr(), expected_types,
+                      false /* expect_generation_vote */),
                   false, expected_available_field_types, std::string(), true));
 
   form_manager.ProvisionallySave(
       form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager.Save();
 }
 
 TEST_F(PasswordFormManagerFillOnAccountSelectTest, ProcessFrame) {
   EXPECT_CALL(*client()->mock_driver(),
               ShowInitialPasswordAccountSuggestions(_));
@@ skipping 163 matching lines @@
       updated, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   credentials_to_update.clear();
   EXPECT_CALL(MockFormSaver::Get(form_manager()), Update(_, _, _, nullptr))
       .WillOnce(SaveArgPointee<2>(&credentials_to_update));
   form_manager()->Save();
 
   EXPECT_THAT(credentials_to_update, IsEmpty());
 }
 
 }  // namespace password_manager