GetLoginsRequest: Use ScopedVector to express ownership of forms

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 208 matching lines @@
     p->best_matches_[match->username_value] = match;
     p->preferred_match_ = match;
   }
 
   void SimulateFetchMatchingLoginsFromPasswordStore(
       PasswordFormManager* manager) {
     // Just need to update the internal states.
     manager->state_ = PasswordFormManager::MATCHING_PHASE;
   }
 
-  void SimulateResponseFromPasswordStore(
-      PasswordFormManager* manager,
-      const std::vector<PasswordForm*>& result) {
-    // Simply call the callback method when request done. This will transfer
-    // the ownership of the objects in |result| to the |manager|.
-    manager->OnGetPasswordStoreResults(result);
-  }
-
   void SanitizePossibleUsernames(PasswordFormManager* p, PasswordForm* form) {
     p->SanitizePossibleUsernames(form);
   }
 
   bool IgnoredResult(PasswordFormManager* p, PasswordForm* form) {
     return p->ShouldIgnoreResult(*form);
   }
 
   PasswordForm* observed_form() { return &observed_form_; }
   PasswordForm* saved_match() { return &saved_match_; }
@@ skipping 515 matching lines @@
   TestPasswordManager password_manager(client());
   PasswordFormManager manager_no_creds(
       &password_manager, client(), client()->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);
+  manager_no_creds.OnGetPasswordStoreResults(ScopedVector<PasswordForm>());
   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()->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);
+  ScopedVector<PasswordForm> simulated_results;
+  simulated_results.push_back(CreateSavedMatch(false));
+  manager_creds.OnGetPasswordStoreResults(simulated_results.Pass());
   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()->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);
+  simulated_results.push_back(CreateSavedMatch(false));
+  manager_dropped_creds.OnGetPasswordStoreResults(simulated_results.Pass());
   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()->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);
+  simulated_results.push_back(CreateSavedMatch(true));
+  manager_blacklisted.OnGetPasswordStoreResults(simulated_results.Pass());
   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()->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");
+  ScopedVector<PasswordForm> simulated_results;
+  simulated_results.push_back(CreateSavedMatch(false));
+  simulated_results.push_back(CreateSavedMatch(false));
+  simulated_results[1]->username_value = ASCIIToUTF16("other@gmail.com");
+  simulated_results[1]->password_element = ASCIIToUTF16("signup_password");
+  simulated_results[1]->username_element = ASCIIToUTF16("signup_username");
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_match);
-  SimulateResponseFromPasswordStore(&manager_match, results);
+  manager_match.OnGetPasswordStoreResults(simulated_results.Pass());
   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()->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;
+  simulated_results.push_back(CreateSavedMatch(false));
+  simulated_results.push_back(CreateSavedMatch(false));
+  simulated_results[1]->username_value = ASCIIToUTF16("other@gmail.com");
+  simulated_results[1]->password_element = ASCIIToUTF16("signup_password");
+  simulated_results[1]->username_element = ASCIIToUTF16("signup_username");
+  simulated_results[1]->type = PasswordForm::TYPE_GENERATED;
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_no_match);
-  SimulateResponseFromPasswordStore(&manager_no_match, results);
+  manager_no_match.OnGetPasswordStoreResults(simulated_results.Pass());
   EXPECT_EQ(2u, password_manager.GetLatestBestMatches().size());
 }
 
 TEST_F(PasswordFormManagerTest, TestSanitizePossibleUsernames) {
   PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
                               false);
   PasswordForm credentials(*observed_form());
   credentials.other_possible_usernames.push_back(ASCIIToUTF16("543-43-1234"));
   credentials.other_possible_usernames.push_back(
       ASCIIToUTF16("378282246310005"));
@@ skipping 47 matching lines @@
                                    client_with_store.driver(), encountered_form,
                                    false);
 
   const PasswordStore::AuthorizationPromptPolicy auth_policy =
       PasswordStore::DISALLOW_PROMPT;
   EXPECT_CALL(*mock_store(),
               GetLogins(encountered_form, auth_policy, &form_manager));
   form_manager.FetchMatchingLoginsFromPasswordStore(auth_policy);
 
   // Password store only has these incomplete credentials.
-  PasswordForm* incomplete_form = new PasswordForm();
+  scoped_ptr<PasswordForm> incomplete_form(new PasswordForm());
   incomplete_form->origin = GURL("http://accounts.google.com/LoginAuth");
   incomplete_form->signon_realm = "http://accounts.google.com/";
   incomplete_form->password_value = ASCIIToUTF16("my_password");
   incomplete_form->username_value = ASCIIToUTF16("my_username");
   incomplete_form->preferred = true;
   incomplete_form->ssl_valid = false;
   incomplete_form->scheme = PasswordForm::SCHEME_HTML;
 
   // We expect to see this form eventually sent to the Password store. It
   // has password/username values from the store and 'username_element',
   // 'password_element', 'submit_element' and 'action' fields copied from
   // the encountered form.
   PasswordForm complete_form(*incomplete_form);
   complete_form.action = encountered_form.action;
   complete_form.password_element = encountered_form.password_element;
   complete_form.username_element = encountered_form.username_element;
   complete_form.submit_element = encountered_form.submit_element;
 
   PasswordForm obsolete_form(*incomplete_form);
   obsolete_form.action = encountered_form.action;
 
   // Feed the incomplete credentials to the manager.
-  std::vector<PasswordForm*> results;
-  results.push_back(incomplete_form);  // Takes ownership.
-  form_manager.OnGetPasswordStoreResults(results);
+  ScopedVector<PasswordForm> simulated_results;
+  simulated_results.push_back(incomplete_form.release());
+  form_manager.OnGetPasswordStoreResults(simulated_results.Pass());
 
   form_manager.ProvisionallySave(
       complete_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   // By now that form has been used once.
   complete_form.times_used = 1;
   obsolete_form.times_used = 1;
 
   // Check that PasswordStore receives an update request with the complete form.
   EXPECT_CALL(*mock_store(), RemoveLogin(obsolete_form));
   EXPECT_CALL(*mock_store(), AddLogin(complete_form));
   form_manager.Save();
 }
 
 TEST_F(PasswordFormManagerTest, TestScoringPublicSuffixMatch) {
   EXPECT_CALL(*(client()->mock_driver()), IsOffTheRecord())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_));
 
   TestPasswordManager password_manager(client());
   PasswordFormManager manager(&password_manager, client(), client()->driver(),
                               *observed_form(), false);
 
   // Simulate having two matches for this form, first comes from different
   // signon realm, but reports the same origin and action as matched form.
   // Second candidate has the same signon realm as the form, but has a different
   // origin and action. Public suffix match is the most important criterion so
   // the second candidate should be selected.
-  std::vector<PasswordForm*> results;
-  results.push_back(CreateSavedMatch(false));
-  results.push_back(CreateSavedMatch(false));
-  results[0]->original_signon_realm = "http://accounts2.google.com";
-  results[1]->origin = GURL("http://accounts.google.com/a/ServiceLoginAuth2");
-  results[1]->action = GURL("http://accounts.google.com/a/ServiceLogin2");
+  ScopedVector<PasswordForm> simulated_results;
+  simulated_results.push_back(CreateSavedMatch(false));
+  simulated_results.push_back(CreateSavedMatch(false));
+  simulated_results[0]->original_signon_realm = "http://accounts2.google.com";
+  simulated_results[1]->origin =
+      GURL("http://accounts.google.com/a/ServiceLoginAuth2");
+  simulated_results[1]->action =
+      GURL("http://accounts.google.com/a/ServiceLogin2");
   SimulateFetchMatchingLoginsFromPasswordStore(&manager);
-  SimulateResponseFromPasswordStore(&manager, results);
+  manager.OnGetPasswordStoreResults(simulated_results.Pass());
   EXPECT_EQ(1u, password_manager.GetLatestBestMatches().size());
   EXPECT_EQ("", password_manager.GetLatestBestMatches()
                     .begin()
                     ->second->original_signon_realm);
 }
 
 TEST_F(PasswordFormManagerTest, InvalidActionURLsDoNotMatch) {
   PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
                               false);
 
@@ skipping 223 matching lines @@
   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.driver(), form, false);
-  std::vector<PasswordForm*> result;
-  result.push_back(CreateSavedMatch(false));
+  ScopedVector<PasswordForm> simulated_results;
+  simulated_results.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);
+  simulated_results[0]->form_data.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Email");
   field.name = ASCIIToUTF16("Email");
   field.form_control_type = "text";
-  result[0]->form_data.fields.push_back(field);
+  simulated_results[0]->form_data.fields.push_back(field);
 
   field.label = ASCIIToUTF16("password");
   field.name = ASCIIToUTF16("password");
   field.form_control_type = "password";
-  result[0]->form_data.fields.push_back(field);
+  simulated_results[0]->form_data.fields.push_back(field);
 
   PasswordForm form_to_save(form);
   form_to_save.preferred = true;
-  form_to_save.username_value = result[0]->username_value;
-  form_to_save.password_value = result[0]->password_value;
+  form_to_save.username_value = simulated_results[0]->username_value;
+  form_to_save.password_value = simulated_results[0]->password_value;
 
   SimulateFetchMatchingLoginsFromPasswordStore(&form_manager);
-  SimulateResponseFromPasswordStore(&form_manager, result);
+  form_manager.OnGetPasswordStoreResults(simulated_results.Pass());
 
   EXPECT_CALL(*client_with_store.mock_driver()->mock_autofill_manager(),
               UploadPasswordForm(_, autofill::ACCOUNT_CREATION_PASSWORD))
       .Times(1);
   form_manager.ProvisionallySave(
       form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   form_manager.Save();
 }
 
 TEST_F(PasswordFormManagerTest, CorrectlySavePasswordWithoutUsernameFields) {
@@ skipping 64 matching lines @@
                                    client_with_store.driver(), *form, false);
 
   const PasswordStore::AuthorizationPromptPolicy auth_policy =
       PasswordStore::DISALLOW_PROMPT;
   EXPECT_CALL(*mock_store(), GetLogins(*form, auth_policy, &form_manager));
   form_manager.FetchMatchingLoginsFromPasswordStore(auth_policy);
 
   // Suddenly, the frame and its driver disappear.
   client_with_store.KillDriver();
 
-  std::vector<PasswordForm*> results;
-  results.push_back(form.release());
-  form_manager.OnGetPasswordStoreResults(results);
+  ScopedVector<PasswordForm> simulated_results;
+  simulated_results.push_back(form.release());
+  form_manager.OnGetPasswordStoreResults(simulated_results.Pass());
 }
 
 }  // namespace password_manager