[Password Generation] Use signatures for form matching

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 <utility>
 
@@ skipping 101 matching lines @@
 }
 
 MATCHER_P(CheckUsernamePtr, username_value, "Username incorrect") {
   return arg && arg->username_value == username_value;
 }
 
 MATCHER_P2(CheckUploadedAutofillTypesAndSignature,
            form_signature,
            expected_types,
            "Unexpected autofill types or form signature") {
-  if (form_signature != arg.FormSignature()) {
+  if (form_signature != arg.FormSignatureAsStr()) {
     // An unexpected form is uploaded.
     return false;
   }
   for (const autofill::AutofillField* field : arg) {
     if (expected_types.find(field->name) == expected_types.end()) {
       if (!field->possible_types().empty()) {
         // Unexpected types are uploaded.
         return false;
       }
     } else {
@@ skipping 16 matching lines @@
       }
     }
   }
   return true;
 }
 
 MATCHER_P2(CheckUploadedGenerationTypesAndSignature,
            form_signature,
            expected_generation_types,
            "Unexpected generation types or form signature") {
-  if (form_signature != arg.FormSignature()) {
+  if (form_signature != arg.FormSignatureAsStr()) {
     // Unexpected form's signature.
     ADD_FAILURE() << "Expected form signature is " << form_signature
-                  << ", but found " << arg.FormSignature();
+                  << ", but found " << arg.FormSignatureAsStr();
     return false;
   }
   for (const autofill::AutofillField* field : arg) {
     if (expected_generation_types.find(field->name) ==
         expected_generation_types.end()) {
       if (field->generation_type() !=
           autofill::AutofillUploadContents::Field::NO_GENERATION) {
         // Unexpected generation type.
         ADD_FAILURE() << "Expected no generation type for the field "
                       << field->name << ", but found "
@@ skipping 319 matching lines @@
     // for its username field.
     base::string16 username_vote =
         (field_type && *field_type == autofill::ACCOUNT_CREATION_PASSWORD)
             ? result[0]->username_element
             : base::string16();
 
     form_manager.OnGetPasswordStoreResults(std::move(result));
     std::string expected_login_signature;
     autofill::FormStructure observed_structure(observed_form_data);
     autofill::FormStructure pending_structure(saved_match()->form_data);
-    if (observed_structure.FormSignature() !=
-            pending_structure.FormSignature() &&
+    if (observed_structure.FormSignatureAsStr() !=
+            pending_structure.FormSignatureAsStr() &&
         times_used == 0) {
-      expected_login_signature = observed_structure.FormSignature();
+      expected_login_signature = observed_structure.FormSignatureAsStr();
     }
     autofill::ServerFieldTypeSet expected_available_field_types;
     expected_available_field_types.insert(autofill::USERNAME);
     std::map<base::string16, autofill::ServerFieldType> expected_types;
     expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE;
     expected_types[saved_match()->username_element] =
         username_vote.empty() ? autofill::UNKNOWN_TYPE : autofill::USERNAME;
     if (field_type) {
       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.FormSignature(), expected_types),
-                      false, expected_available_field_types,
-                      expected_login_signature, true));
+                  StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
+                                         pending_structure.FormSignatureAsStr(),
+                                         expected_types),
+                                     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();
   }
 
@@ skipping 45 matching lines @@
     expected_types[observed_form_.username_element] = autofill::USERNAME;
     expected_types[observed_form_.password_element] = autofill::PASSWORD;
     expected_types[observed_form_.new_password_element] = field_type;
 
     autofill::ServerFieldTypeSet expected_available_field_types;
     expected_available_field_types.insert(autofill::USERNAME);
     expected_available_field_types.insert(autofill::PASSWORD);
     expected_available_field_types.insert(field_type);
 
     std::string observed_form_signature =
-        autofill::FormStructure(observed_form()->form_data).FormSignature();
+        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.FormSignature();
+      expected_login_signature = pending_structure.FormSignatureAsStr();
     }
     EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
                 StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
                                        observed_form_signature, expected_types),
                                    false, expected_available_field_types,
                                    expected_login_signature, true));
 
     switch (field_type) {
       case autofill::NEW_PASSWORD:
         form_manager.Update(*saved_match());
@@ skipping 97 matching lines @@
              autofill::AutofillUploadContents::Field::PasswordGenerationType>
         expected_generation_types;
     expected_generation_types[generation_element] = expected_generation_type;
 
     autofill::FormStructure form_structure(submitted_form.form_data);
 
     EXPECT_CALL(
         *client()->mock_driver()->mock_autofill_download_manager(),
         StartUploadRequest(
             CheckUploadedGenerationTypesAndSignature(
-                form_structure.FormSignature(), expected_generation_types),
+                form_structure.FormSignatureAsStr(), expected_generation_types),
             false, expected_available_field_types, std::string(), true));
 
     form_manager.ProvisionallySave(
         submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
     form_manager.Save();
   }
 
   PasswordForm* observed_form() { return &observed_form_; }
   PasswordForm* saved_match() { return &saved_match_; }
   PasswordForm* psl_saved_match() { return &psl_saved_match_; }
@@ skipping 2030 matching lines @@
   std::map<base::string16, autofill::ServerFieldType> expected_types;
   expected_types[observed_form()->password_element] = autofill::PASSWORD;
   expected_types[observed_form()->new_password_element] =
       autofill::NEW_PASSWORD;
 
   autofill::ServerFieldTypeSet expected_available_field_types;
   expected_available_field_types.insert(autofill::PASSWORD);
   expected_available_field_types.insert(autofill::NEW_PASSWORD);
 
   std::string observed_form_signature =
-      autofill::FormStructure(observed_form()->form_data).FormSignature();
+      autofill::FormStructure(observed_form()->form_data).FormSignatureAsStr();
 
   std::string expected_login_signature =
-      autofill::FormStructure(saved_match()->form_data).FormSignature();
+      autofill::FormStructure(saved_match()->form_data).FormSignatureAsStr();
 
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
                                      observed_form_signature, expected_types),
                                  false, expected_available_field_types,
                                  expected_login_signature, true));
 
   form_manager.Update(*saved_match());
 }
 
@@ skipping 198 matching lines @@
   expected_available_field_types.insert(autofill::USERNAME);
   expected_types[saved_match()->username_element] = autofill::USERNAME;
   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.FormSignature(), expected_types),
+                      pending_structure.FormSignatureAsStr(), expected_types),
                   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 70 matching lines @@
           ->ProcessMatches(all_matches, 0u);
 
       EXPECT_EQ(1u, form_manager.best_matches().size());
       EXPECT_EQ(kCorrectScheme,
                 form_manager.best_matches().begin()->second->scheme);
     }
   }
 }
 
 }  // namespace password_manager