Make FormFetcher a PasswordStoreConsumer

chrome/browser/ui/passwords/manage_passwords_state_unittest.cc

 // Copyright 2015 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 "chrome/browser/ui/passwords/manage_passwords_state.h"
 
 #include <iterator>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "components/password_manager/core/browser/fake_form_fetcher.h"
 #include "components/password_manager/core/browser/password_form_manager.h"
 #include "components/password_manager/core/browser/password_manager.h"
 #include "components/password_manager/core/browser/stub_form_saver.h"
 #include "components/password_manager/core/browser/stub_password_manager_client.h"
 #include "components/password_manager/core/browser/stub_password_manager_driver.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
@@ skipping 12 matching lines @@
   std::vector<const autofill::PasswordForm*> result;
   std::transform(forms.begin(), forms.end(), std::back_inserter(result),
                  [](const std::unique_ptr<autofill::PasswordForm>& form) {
                    return form.get();
                  });
   return result;
 }
 
 class ManagePasswordsStateTest : public testing::Test {
  public:
-  ManagePasswordsStateTest() : password_manager_(&stub_client_) {}
+  ManagePasswordsStateTest() : password_manager_(&stub_client_) {
+    fetcher_.Fetch();
+  }
 
   void SetUp() override {
     test_local_form_.origin = GURL("http://example.com");
     test_local_form_.username_value = base::ASCIIToUTF16("username");
     test_local_form_.username_element = base::ASCIIToUTF16("username_element");
     test_local_form_.password_value = base::ASCIIToUTF16("12345");
 
     test_psl_form_.origin = GURL("http://1.example.com");
     test_psl_form_.username_value = base::ASCIIToUTF16("username_psl");
     test_psl_form_.username_element = base::ASCIIToUTF16("username_element");
@@ skipping 13 matching lines @@
 
     passwords_data_.set_client(&stub_client_);
   }
 
   autofill::PasswordForm& test_local_form() { return test_local_form_; }
   autofill::PasswordForm& test_psl_form() { return test_psl_form_; }
   autofill::PasswordForm& test_submitted_form() { return test_submitted_form_; }
   autofill::PasswordForm& test_local_federated_form() {
     return test_local_federated_form_;
   }
-  std::vector<std::unique_ptr<autofill::PasswordForm>>& test_stored_forms() {
+  std::vector<const autofill::PasswordForm*>& test_stored_forms() {
     return test_stored_forms_;
   }
   ManagePasswordsState& passwords_data() { return passwords_data_; }
 
   // Returns a PasswordFormManager containing |test_stored_forms_| as the best
   // matches.
   std::unique_ptr<password_manager::PasswordFormManager> CreateFormManager();
 
   // Returns a PasswordFormManager containing test_local_federated_form() as a
   // stored federated credential.
@@ skipping 13 matching lines @@
   MOCK_METHOD1(CredentialCallback, void(const autofill::PasswordForm*));
 
  private:
   // Implements both CreateFormManager and CreateFormManagerWithFederation.
   std::unique_ptr<password_manager::PasswordFormManager>
   CreateFormManagerInternal(bool include_federated);
 
   password_manager::StubPasswordManagerClient stub_client_;
   password_manager::StubPasswordManagerDriver driver_;
   password_manager::PasswordManager password_manager_;
+  password_manager::FakeFormFetcher fetcher_;
 
   ManagePasswordsState passwords_data_;
   autofill::PasswordForm test_local_form_;
   autofill::PasswordForm test_psl_form_;
   autofill::PasswordForm test_submitted_form_;
   autofill::PasswordForm test_local_federated_form_;
-  std::vector<std::unique_ptr<autofill::PasswordForm>> test_stored_forms_;
+  std::vector<const autofill::PasswordForm*> test_stored_forms_;
 };
 
 std::unique_ptr<password_manager::PasswordFormManager>
 ManagePasswordsStateTest::CreateFormManager() {
   return CreateFormManagerInternal(false);
 }
 
 std::unique_ptr<password_manager::PasswordFormManager>
 ManagePasswordsStateTest::CreateFormManagerWithFederation() {
   return CreateFormManagerInternal(true);
 }
 
 std::unique_ptr<password_manager::PasswordFormManager>
 ManagePasswordsStateTest::CreateFormManagerInternal(bool include_federated) {
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       new password_manager::PasswordFormManager(
           &password_manager_, &stub_client_, driver_.AsWeakPtr(),
           test_local_form(),
-          base::WrapUnique(new password_manager::StubFormSaver)));
+          base::WrapUnique(new password_manager::StubFormSaver), &fetcher_));
+  fetcher_.SetNonFederated(test_stored_forms_, 0u);
   if (include_federated) {
-    test_stored_forms_.push_back(
-        base::MakeUnique<autofill::PasswordForm>(test_local_federated_form()));
+    fetcher_.set_federated({&test_local_federated_form()});
   }
-  test_form_manager->OnGetPasswordStoreResults(std::move(test_stored_forms_));
   EXPECT_EQ(include_federated ? 1u : 0u,
             test_form_manager->form_fetcher()->GetFederatedMatches().size());
   if (include_federated) {
     EXPECT_EQ(
         test_local_federated_form(),
         *test_form_manager->form_fetcher()->GetFederatedMatches().front());
   }
   return test_form_manager;
 }
 
@@ skipping 105 matching lines @@
 TEST_F(ManagePasswordsStateTest, DefaultState) {
   EXPECT_THAT(passwords_data().GetCurrentForms(), IsEmpty());
   EXPECT_EQ(password_manager::ui::INACTIVE_STATE, passwords_data().state());
   EXPECT_EQ(GURL::EmptyGURL(), passwords_data().origin());
   EXPECT_FALSE(passwords_data().form_manager());
 
   TestNoisyUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PasswordSubmitted) {
-  test_stored_forms().push_back(
-      base::MakeUnique<autofill::PasswordForm>(test_local_form()));
-  test_stored_forms().push_back(
-      base::MakeUnique<autofill::PasswordForm>(test_psl_form()));
+  test_stored_forms().push_back(&test_local_form());
+  test_stored_forms().push_back(&test_psl_form());
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   passwords_data().OnPendingPassword(std::move(test_form_manager));
 
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             passwords_data().state());
   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
   ASSERT_TRUE(passwords_data().form_manager());
   EXPECT_EQ(test_submitted_form(),
             passwords_data().form_manager()->pending_credentials());
   TestAllUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PasswordSaved) {
-  test_stored_forms().push_back(
-      base::MakeUnique<autofill::PasswordForm>(test_local_form()));
+  test_stored_forms().push_back(&test_local_form());
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   passwords_data().OnPendingPassword(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             passwords_data().state());
 
   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
@@ skipping 54 matching lines @@
 
   passwords_data().TransitionToState(password_manager::ui::MANAGE_STATE);
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_EQ(password_manager::ui::MANAGE_STATE, passwords_data().state());
   EXPECT_EQ(test_local_form().origin, passwords_data().origin());
   TestAllUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, AutomaticPasswordSave) {
-  test_stored_forms().push_back(
-      base::MakeUnique<autofill::PasswordForm>(test_psl_form()));
+  test_stored_forms().push_back(&test_psl_form());
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   passwords_data().OnAutomaticPasswordSave(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::CONFIRMATION_STATE, passwords_data().state());
   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
   ASSERT_TRUE(passwords_data().form_manager());
@@ skipping 165 matching lines @@
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   passwords_data().OnUpdatePassword(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE,
             passwords_data().state());
 
   TestBlacklistedUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PasswordUpdateSubmitted) {
-  test_stored_forms().push_back(
-      base::MakeUnique<autofill::PasswordForm>(test_local_form()));
-  test_stored_forms().push_back(
-      base::MakeUnique<autofill::PasswordForm>(test_psl_form()));
+  test_stored_forms().push_back(&test_local_form());
+  test_stored_forms().push_back(&test_psl_form());
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   passwords_data().OnUpdatePassword(std::move(test_form_manager));
 
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(test_local_form())));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE,
             passwords_data().state());
   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
   ASSERT_TRUE(passwords_data().form_manager());
   EXPECT_EQ(test_submitted_form(),
             passwords_data().form_manager()->pending_credentials());
   TestAllUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, AndroidPasswordUpdateSubmitted) {
   autofill::PasswordForm android_form;
   android_form.signon_realm = "android://dHJhc2g=@com.example.android/";
   android_form.origin = GURL(android_form.signon_realm);
   android_form.username_value = test_submitted_form().username_value;
   android_form.password_value = base::ASCIIToUTF16("old pass");
-  test_stored_forms().push_back(
-      base::MakeUnique<autofill::PasswordForm>(android_form));
+  test_stored_forms().push_back(&android_form);
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   passwords_data().OnUpdatePassword(std::move(test_form_manager));
 
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               ElementsAre(Pointee(android_form)));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE,
             passwords_data().state());
   EXPECT_EQ(test_submitted_form().origin, passwords_data().origin());
   ASSERT_TRUE(passwords_data().form_manager());
   android_form.password_value = test_submitted_form().password_value;
   EXPECT_EQ(android_form,
             passwords_data().form_manager()->pending_credentials());
   TestAllUpdates();
 }
 
 TEST_F(ManagePasswordsStateTest, PasswordUpdateSubmittedWithFederations) {
-  test_stored_forms().push_back(
-      base::MakeUnique<autofill::PasswordForm>(test_local_form()));
+  test_stored_forms().push_back(&test_local_form());
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManagerWithFederation());
   test_form_manager->ProvisionallySave(
       test_submitted_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   passwords_data().OnUpdatePassword(std::move(test_form_manager));
 
   EXPECT_THAT(passwords_data().GetCurrentForms(),
               UnorderedElementsAre(Pointee(test_local_form()),
                                    Pointee(test_local_federated_form())));
@@ skipping 23 matching lines @@
   passwords_data().OnRequestCredentials(
       std::vector<std::unique_ptr<autofill::PasswordForm>>(),
       test_local_form().origin);
   passwords_data().set_credentials_callback(base::Bind(
       &ManagePasswordsStateTest::CredentialCallback, base::Unretained(this)));
   EXPECT_CALL(*this, CredentialCallback(&test_local_federated_form()));
   passwords_data().ChooseCredential(&test_local_federated_form());
 }
 
 }  // namespace