Refactor Autofill for out of process iframes (OOPIF).

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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
@@ skipping 89 matching lines @@
 
   virtual bool ShouldFilterAutofillResult(
       const autofill::PasswordForm& form) override {
     if (form == form_to_filter_)
       return true;
     return false;
   }
 
   virtual PrefService* GetPrefs() override { return &prefs_; }
   virtual PasswordStore* GetPasswordStore() override { return password_store_; }
-  virtual PasswordManagerDriver* GetDriver() override { return &driver_; }
 
   void SetFormToFilter(const autofill::PasswordForm& form) {
     form_to_filter_ = form;
   }
 
   MockPasswordManagerDriver* mock_driver() { return &driver_; }
 
  private:
   autofill::PasswordForm form_to_filter_;
 
   TestingPrefServiceSimple prefs_;
   PasswordStore* password_store_;
   NiceMock<MockPasswordManagerDriver> driver_;
 };
 
 class TestPasswordManager : public PasswordManager {
  public:
-  explicit TestPasswordManager(PasswordManagerClient* client)
+  explicit TestPasswordManager(TestPasswordManagerClient* client)
       : PasswordManager(client) {}
 
-  void Autofill(const autofill::PasswordForm& form_for_autofill,
+  void Autofill(password_manager::PasswordManagerDriver* driver,
+                const autofill::PasswordForm& form_for_autofill,
                 const autofill::PasswordFormMap& best_matches,
                 const autofill::PasswordForm& preferred_match,
                 bool wait_for_username) const override {
     best_matches_ = best_matches;
   }
 
   const autofill::PasswordFormMap& GetLatestBestMatches() {
     return best_matches_;
   }
 
@@ skipping 195 matching lines @@
   EXPECT_TRUE(manager.IsNewLogin());
   EXPECT_FALSE(manager.IsPendingCredentialsPublicSuffixMatch());
 }
 
 TEST_F(PasswordFormManagerTest, PSLMatchedCredentialsMetadataUpdated) {
   TestPasswordManagerClient client_with_store(mock_store());
   EXPECT_CALL(*(client_with_store.mock_driver()), IsOffTheRecord())
       .WillRepeatedly(Return(false));
 
   TestPasswordManager manager(&client_with_store);
-  PasswordFormManager form_manager(&manager,
-                                   &client_with_store,
+  PasswordFormManager form_manager(&manager, &client_with_store,
                                    client_with_store.mock_driver(),
-                                   *observed_form(),
-                                   false);
+                                   *observed_form(), false);
 
   // The suggestion needs to be PSL-matched.
   saved_match()->original_signon_realm = "www.example.org";
   SimulateMatchingPhase(&form_manager, RESULT_MATCH_FOUND);
 
   PasswordForm submitted_form(*observed_form());
   submitted_form.preferred = true;
   submitted_form.username_value = saved_match()->username_value;
   submitted_form.password_value = saved_match()->password_value;
   submitted_form.origin = saved_match()->origin;
@@ skipping 101 matching lines @@
   // Given that |observed_form| was most likely a change password form, it
   // should not serve as a source for updating meta-information stored with the
   // old credentials, such as element names, as they are likely going to be
   // different between change password and login forms. To test this in depth,
   // forcibly wipe |submit_element|, which should normally trigger updating this
   // field from |observed_form| in the UpdateLogin() step as a special case. We
   // will verify in the end that this did not happen.
   saved_match()->submit_element.clear();
 
   TestPasswordManagerClient client_with_store(mock_store());
-  PasswordFormManager manager(NULL,
-                              &client_with_store,
-                              client_with_store.GetDriver(),
-                              *observed_form(),
+  PasswordFormManager manager(NULL, &client_with_store,
+                              client_with_store.mock_driver(), *observed_form(),
                               false);
   EXPECT_CALL(*client_with_store.mock_driver(), IsOffTheRecord())
       .WillRepeatedly(Return(false));
   SimulateMatchingPhase(&manager, RESULT_MATCH_FOUND);
 
   // User submits current and new credentials to the observed form.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = saved_match()->password_value;
   credentials.new_password_value = ASCIIToUTF16("test2");
@@ skipping 98 matching lines @@
   // action URL, not the one observed on page load.
   EXPECT_EQ(new_action, GetPendingCredentials(&manager)->action);
 }
 
 TEST_F(PasswordFormManagerTest, TestAlternateUsername) {
   scoped_refptr<TestPasswordStore> password_store = new TestPasswordStore;
   CHECK(password_store->Init(syncer::SyncableService::StartSyncFlare()));
 
   TestPasswordManagerClient client_with_store(password_store.get());
   TestPasswordManager password_manager(&client_with_store);
-  PasswordFormManager manager(&password_manager,
-                              &client_with_store,
-                              client_with_store.GetDriver(),
-                              *observed_form(),
+  PasswordFormManager manager(&password_manager, &client_with_store,
+                              client_with_store.mock_driver(), *observed_form(),
                               false);
   EXPECT_CALL(*client_with_store.mock_driver(),
               AllowPasswordGenerationForForm(_)).Times(1);
   EXPECT_CALL(*client_with_store.mock_driver(), IsOffTheRecord())
       .WillRepeatedly(Return(false));
 
   password_store->AddLogin(*saved_match());
   manager.FetchMatchingLoginsFromPasswordStore(PasswordStore::ALLOW_PROMPT);
   RunAllPendingTasks();
 
@@ skipping 14 matching lines @@
   TestPasswordStore::PasswordMap passwords = password_store->stored_passwords();
   EXPECT_EQ(1U, passwords.size());
   ASSERT_EQ(1U, passwords[saved_match()->signon_realm].size());
   EXPECT_EQ(saved_match()->username_value,
             passwords[saved_match()->signon_realm][0].username_value);
   EXPECT_EQ(0U,
             passwords[saved_match()->signon_realm][0]
                 .other_possible_usernames.size());
 
   // This time use an alternate username
-  PasswordFormManager manager_alt(&password_manager,
-                                  &client_with_store,
-                                  client_with_store.GetDriver(),
-                                  *observed_form(),
-                                  false);
+  PasswordFormManager manager_alt(&password_manager, &client_with_store,
+                                  client_with_store.mock_driver(),
+                                  *observed_form(), false);
   EXPECT_CALL(*client_with_store.mock_driver(),
               AllowPasswordGenerationForForm(_)).Times(1);
   password_store->Clear();
   password_store->AddLogin(*saved_match());
   manager_alt.FetchMatchingLoginsFromPasswordStore(PasswordStore::ALLOW_PROMPT);
   RunAllPendingTasks();
 
   base::string16 new_username = saved_match()->other_possible_usernames[0];
   login.username_value = new_username;
   manager_alt.ProvisionallySave(
@@ skipping 99 matching lines @@
   // Form with neither a password_element nor a username_element.
   credentials.username_element.clear();
   credentials.password_element.clear();
   PasswordFormManager manager4(NULL, NULL, NULL, credentials, false);
   SimulateMatchingPhase(&manager4, RESULT_NO_MATCH);
   EXPECT_TRUE(manager4.HasValidPasswordForm());
 }
 
 TEST_F(PasswordFormManagerTest, TestSendNotBlacklistedMessage) {
   TestPasswordManager password_manager(client());
-  PasswordFormManager manager_no_creds(&password_manager,
-                                       client(),
-                                       client()->GetDriver(),
-                                       *observed_form(),
-                                       false);
+  PasswordFormManager manager_no_creds(&password_manager, client(),
+                                       client()->mock_driver(),
+                                       *observed_form(), false);
 
   // First time sign-up attempt. Password store does not contain matching
   // credentials. AllowPasswordGenerationForForm should be called to send the
   // "not blacklisted" message.
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_))
       .Times(1);
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_no_creds);
   std::vector<PasswordForm*> result;
   SimulateResponseFromPasswordStore(&manager_no_creds, result);
   Mock::VerifyAndClearExpectations(client()->mock_driver());
 
   // Signing up on a previously visited site. Credentials are found in the
   // password store, and are not blacklisted. AllowPasswordGenerationForForm
   // should be called to send the "not blacklisted" message.
-  PasswordFormManager manager_creds(&password_manager,
-                                    client(),
-                                    client()->GetDriver(),
-                                    *observed_form(),
+  PasswordFormManager manager_creds(&password_manager, client(),
+                                    client()->mock_driver(), *observed_form(),
                                     false);
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_))
       .Times(1);
   EXPECT_CALL(*(client()->mock_driver()), IsOffTheRecord())
       .WillRepeatedly(Return(false));
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_creds);
   // We need add heap allocated objects to result.
   result.push_back(CreateSavedMatch(false));
   SimulateResponseFromPasswordStore(&manager_creds, result);
   Mock::VerifyAndClearExpectations(client()->mock_driver());
 
   // There are cases, such as when a form is explicitly for creating a new
   // password, where we may ignore saved credentials. Make sure that we still
   // allow generation in that case.
   PasswordForm signup_form(*observed_form());
   signup_form.new_password_element = base::ASCIIToUTF16("new_password_field");
 
-  PasswordFormManager manager_dropped_creds(&password_manager,
-                                            client(),
-                                            client()->GetDriver(),
-                                            signup_form,
-                                            false);
+  PasswordFormManager manager_dropped_creds(
+      &password_manager, client(), client()->mock_driver(), signup_form, false);
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_))
       .Times(1);
   EXPECT_CALL(*(client()->mock_driver()), IsOffTheRecord())
       .WillRepeatedly(Return(false));
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_dropped_creds);
   result.clear();
   result.push_back(CreateSavedMatch(false));
   SimulateResponseFromPasswordStore(&manager_dropped_creds, result);
   Mock::VerifyAndClearExpectations(client()->mock_driver());
 
   // Signing up on a previously visited site. Credentials are found in the
   // password store, but they are blacklisted. AllowPasswordGenerationForForm
   // should not be called and no "not blacklisted" message sent.
-  PasswordFormManager manager_blacklisted(&password_manager,
-                                          client(),
-                                          client()->GetDriver(),
-                                          *observed_form(),
-                                          false);
+  PasswordFormManager manager_blacklisted(&password_manager, client(),
+                                          client()->mock_driver(),
+                                          *observed_form(), false);
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_))
       .Times(0);
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_blacklisted);
   result.clear();
   result.push_back(CreateSavedMatch(true));
   SimulateResponseFromPasswordStore(&manager_blacklisted, result);
   Mock::VerifyAndClearExpectations(client()->mock_driver());
 }
 
 TEST_F(PasswordFormManagerTest, TestForceInclusionOfGeneratedPasswords) {
   // Simulate having two matches for this origin, one of which was from a form
   // with different HTML tags for elements. Because of scoring differences,
   // only the first form will be sent to Autofill().
   TestPasswordManager password_manager(client());
-  PasswordFormManager manager_match(&password_manager,
-                                    client(),
-                                    client()->GetDriver(),
-                                    *observed_form(),
+  PasswordFormManager manager_match(&password_manager, client(),
+                                    client()->mock_driver(), *observed_form(),
                                     false);
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_))
       .Times(1);
   EXPECT_CALL(*(client()->mock_driver()), IsOffTheRecord())
       .WillRepeatedly(Return(false));
 
   std::vector<PasswordForm*> results;
   results.push_back(CreateSavedMatch(false));
   results.push_back(CreateSavedMatch(false));
   results[1]->username_value = ASCIIToUTF16("other@gmail.com");
   results[1]->password_element = ASCIIToUTF16("signup_password");
   results[1]->username_element = ASCIIToUTF16("signup_username");
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_match);
   SimulateResponseFromPasswordStore(&manager_match, results);
   EXPECT_EQ(1u, password_manager.GetLatestBestMatches().size());
   results.clear();
 
   // Same thing, except this time the credentials that don't match quite as
   // well are generated. They should now be sent to Autofill().
-  PasswordFormManager manager_no_match(&password_manager,
-                                       client(),
-                                       client()->GetDriver(),
-                                       *observed_form(),
-                                       false);
+  PasswordFormManager manager_no_match(&password_manager, client(),
+                                       client()->mock_driver(),
+                                       *observed_form(), false);
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_))
       .Times(1);
 
   results.push_back(CreateSavedMatch(false));
   results.push_back(CreateSavedMatch(false));
   results[1]->username_value = ASCIIToUTF16("other@gmail.com");
   results[1]->password_element = ASCIIToUTF16("signup_password");
   results[1]->username_element = ASCIIToUTF16("signup_username");
   results[1]->type = PasswordForm::TYPE_GENERATED;
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_no_match);
@@ skipping 265 matching lines @@
   first.action = observed_form()->action;
   first.password_value = ASCIIToUTF16("first");
   password_store->AddLogin(first);
 
   PasswordForm second(first);
   second.origin = GURL("http://accounts.google.com/a/AddLogin");
   second.password_value = ASCIIToUTF16("second");
   second.preferred = false;
   password_store->AddLogin(second);
 
-  PasswordFormManager storing_manager(&password_manager,
-                                      &client_with_store,
-                                      client_with_store.GetDriver(),
-                                      *observed_form(),
-                                      false);
+  PasswordFormManager storing_manager(&password_manager, &client_with_store,
+                                      client_with_store.mock_driver(),
+                                      *observed_form(), false);
   storing_manager.FetchMatchingLoginsFromPasswordStore(
       PasswordStore::ALLOW_PROMPT);
   RunAllPendingTasks();
 
   // We always take the last credential with a particular username, regardless
   // of which ones are labeled preferred.
   EXPECT_EQ(ASCIIToUTF16("second"),
             storing_manager.preferred_match()->password_value);
 
   PasswordForm login(*observed_form());
   login.username_value = saved_match()->username_value;
   login.password_value = ASCIIToUTF16("third");
   login.preferred = true;
   storing_manager.ProvisionallySave(
       login, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   EXPECT_FALSE(storing_manager.IsNewLogin());
   storing_manager.Save();
   RunAllPendingTasks();
 
-  PasswordFormManager retrieving_manager(&password_manager,
-                                         &client_with_store,
-                                         client_with_store.GetDriver(),
-                                         *observed_form(),
-                                         false);
+  PasswordFormManager retrieving_manager(&password_manager, &client_with_store,
+                                         client_with_store.mock_driver(),
+                                         *observed_form(), false);
 
   retrieving_manager.FetchMatchingLoginsFromPasswordStore(
       PasswordStore::ALLOW_PROMPT);
   RunAllPendingTasks();
 
   // Make sure that the preferred match is updated appropriately.
   EXPECT_EQ(ASCIIToUTF16("third"),
             retrieving_manager.preferred_match()->password_value);
   password_store->Shutdown();
 }
 
 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword) {
   TestPasswordManagerClient client_with_store(mock_store());
   TestPasswordManager password_manager(&client_with_store);
   EXPECT_CALL(*client_with_store.mock_driver(), IsOffTheRecord())
       .WillRepeatedly(Return(false));
 
   // For newly saved passwords, upload a vote for autofill::PASSWORD.
-  PasswordFormManager form_manager(&password_manager,
-                                   &client_with_store,
-                                   client_with_store.GetDriver(),
-                                   *saved_match(),
-                                   false);
+  PasswordFormManager form_manager(&password_manager, &client_with_store,
+                                   client_with_store.mock_driver(),
+                                   *saved_match(), false);
   SimulateMatchingPhase(&form_manager, RESULT_NO_MATCH);
 
   PasswordForm form_to_save(*saved_match());
   form_to_save.preferred = true;
   form_to_save.username_value = ASCIIToUTF16("username");
   form_to_save.password_value = ASCIIToUTF16("1234");
 
   EXPECT_CALL(*client_with_store.mock_driver()->mock_autofill_manager(),
               UploadPasswordForm(_, autofill::PASSWORD)).Times(1);
   form_manager.ProvisionallySave(
       form_to_save,
       PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager.Save();
   Mock::VerifyAndClearExpectations(&form_manager);
 
   // Do not upload a vote if the user is blacklisting the form.
-  PasswordFormManager blacklist_form_manager(&password_manager,
-                                             &client_with_store,
-                                             client_with_store.GetDriver(),
-                                             *saved_match(),
-                                             false);
+  PasswordFormManager blacklist_form_manager(
+      &password_manager, &client_with_store, client_with_store.mock_driver(),
+      *saved_match(), false);
   SimulateMatchingPhase(&blacklist_form_manager, RESULT_NO_MATCH);
 
   EXPECT_CALL(*client_with_store.mock_driver()->mock_autofill_manager(),
               UploadPasswordForm(_, autofill::PASSWORD)).Times(0);
   blacklist_form_manager.PermanentlyBlacklist();
   Mock::VerifyAndClearExpectations(&blacklist_form_manager);
 }
 
 TEST_F(PasswordFormManagerTest, UploadFormData_AccountCreationPassword) {
   TestPasswordManagerClient client_with_store(mock_store());
   TestPasswordManager password_manager(&client_with_store);
   EXPECT_CALL(*client_with_store.mock_driver(), IsOffTheRecord())
       .WillRepeatedly(Return(false));
 
   PasswordForm form(*observed_form());
 
   autofill::FormFieldData field;
   field.label = ASCIIToUTF16("Email");
   field.name = ASCIIToUTF16("Email");
   field.form_control_type = "text";
   form.form_data.fields.push_back(field);
 
   field.label = ASCIIToUTF16("password");
   field.name = ASCIIToUTF16("password");
   field.form_control_type = "password";
   form.form_data.fields.push_back(field);
 
-  PasswordFormManager form_manager(&password_manager,
-                                   &client_with_store,
-                                   client_with_store.GetDriver(),
-                                   form,
+  PasswordFormManager form_manager(&password_manager, &client_with_store,
+                                   client_with_store.mock_driver(), form,
                                    false);
   std::vector<PasswordForm*> result;
   result.push_back(CreateSavedMatch(false));
 
   field.label = ASCIIToUTF16("full_name");
   field.name = ASCIIToUTF16("full_name");
   field.form_control_type = "text";
   result[0]->form_data.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Email");
@@ skipping 32 matching lines @@
   EXPECT_CALL(*client_with_store.mock_driver(),
               AllowPasswordGenerationForForm(_)).Times(2);
   EXPECT_CALL(*client_with_store.mock_driver(), IsOffTheRecord())
       .WillRepeatedly(Return(false));
 
   PasswordForm form(*observed_form());
   form.username_element.clear();
   form.password_value = ASCIIToUTF16("password");
   form.preferred = true;
 
-  PasswordFormManager storing_manager(&password_manager,
-                                      &client_with_store,
-                                      client_with_store.GetDriver(),
-                                      *observed_form(),
-                                      false);
+  PasswordFormManager storing_manager(&password_manager, &client_with_store,
+                                      client_with_store.mock_driver(),
+                                      *observed_form(), false);
   storing_manager.FetchMatchingLoginsFromPasswordStore(
       PasswordStore::ALLOW_PROMPT);
   RunAllPendingTasks();
 
   storing_manager.ProvisionallySave(
       form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   EXPECT_TRUE(storing_manager.IsNewLogin());
   storing_manager.Save();
   RunAllPendingTasks();
 
-  PasswordFormManager retrieving_manager(&password_manager,
-                                         &client_with_store,
-                                         client_with_store.GetDriver(),
-                                         *observed_form(),
-                                         false);
+  PasswordFormManager retrieving_manager(&password_manager, &client_with_store,
+                                         client_with_store.mock_driver(),
+                                         *observed_form(), false);
 
   retrieving_manager.FetchMatchingLoginsFromPasswordStore(
       PasswordStore::ALLOW_PROMPT);
   RunAllPendingTasks();
 
   // Make sure that the preferred match is updated appropriately.
   EXPECT_EQ(ASCIIToUTF16("password"),
             retrieving_manager.preferred_match()->password_value);
   password_store->Shutdown();
 }
 
 }  // namespace password_manager