Make FormFetcher a PasswordStoreConsumer

chrome/browser/ui/passwords/manage_passwords_ui_controller_unittest.cc

 // Copyright 2014 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 <map>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/ui/passwords/manage_passwords_bubble_model.h"
 #include "chrome/browser/ui/passwords/manage_passwords_icon_view.h"
 #include "chrome/browser/ui/passwords/manage_passwords_ui_controller_mock.h"
 #include "chrome/browser/ui/passwords/password_dialog_controller.h"
 #include "chrome/browser/ui/passwords/password_dialog_prompts.h"
 #include "chrome/browser/ui/passwords/passwords_model_delegate.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/core/common/password_form.h"
+#include "components/password_manager/core/browser/fake_form_fetcher.h"
 #include "components/password_manager/core/browser/password_bubble_experiment.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/statistics_table.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 "components/password_manager/core/common/password_manager_ui.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
@@ skipping 117 matching lines @@
   variations::AssociateVariationParams(kSmartBubbleExperimentName, "A", params);
   ASSERT_TRUE(
       base::FieldTrialList::CreateFieldTrial(kSmartBubbleExperimentName, "A"));
 }
 
 }  // namespace
 
 class ManagePasswordsUIControllerTest : public ChromeRenderViewHostTestHarness {
  public:
   ManagePasswordsUIControllerTest()
-      : password_manager_(&client_), field_trial_list_(nullptr) {}
+      : password_manager_(&client_), field_trial_list_(nullptr) {
+    fetcher_.Fetch();
+  }
 
   void SetUp() override;
 
+  password_manager::FakeFormFetcher& fetcher() { return fetcher_; }
   autofill::PasswordForm& test_local_form() { return test_local_form_; }
   autofill::PasswordForm& test_federated_form() { return test_federated_form_; }
   DialogPromptMock& dialog_prompt() { return dialog_prompt_; }
 
   TestManagePasswordsUIController* controller() {
     return static_cast<TestManagePasswordsUIController*>(
         ManagePasswordsUIController::FromWebContents(web_contents()));
   }
 
   void ExpectIconStateIs(password_manager::ui::State state);
   void ExpectIconAndControllerStateIs(password_manager::ui::State state);
 
   std::unique_ptr<password_manager::PasswordFormManager>
   CreateFormManagerWithBestMatches(
       const autofill::PasswordForm& observed_form,
-      std::vector<std::unique_ptr<autofill::PasswordForm>> best_matches);
+      const std::vector<const autofill::PasswordForm*>& best_matches);
 
   std::unique_ptr<password_manager::PasswordFormManager> CreateFormManager();
 
   // Tests that the state is not changed when the password is autofilled.
   void TestNotChangingStateOnAutofill(
       password_manager::ui::State state);
 
   MOCK_METHOD1(CredentialCallback, void(const autofill::PasswordForm*));
 
  private:
   password_manager::StubPasswordManagerClient client_;
   password_manager::StubPasswordManagerDriver driver_;
   password_manager::PasswordManager password_manager_;
+  password_manager::FakeFormFetcher fetcher_;
 
   autofill::PasswordForm test_local_form_;
   autofill::PasswordForm test_federated_form_;
   base::FieldTrialList field_trial_list_;
   DialogPromptMock dialog_prompt_;
 };
 
 void ManagePasswordsUIControllerTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
 
@@ skipping 26 matching lines @@
 
 void ManagePasswordsUIControllerTest::ExpectIconAndControllerStateIs(
     password_manager::ui::State state) {
   ExpectIconStateIs(state);
   EXPECT_EQ(state, controller()->GetState());
 }
 
 std::unique_ptr<password_manager::PasswordFormManager>
 ManagePasswordsUIControllerTest::CreateFormManagerWithBestMatches(
     const autofill::PasswordForm& observed_form,
-    std::vector<std::unique_ptr<autofill::PasswordForm>> best_matches) {
+    const std::vector<const autofill::PasswordForm*>& best_matches) {
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       new password_manager::PasswordFormManager(
           &password_manager_, &client_, driver_.AsWeakPtr(), observed_form,
-          base::WrapUnique(new password_manager::StubFormSaver)));
-  test_form_manager->OnGetPasswordStoreResults(std::move(best_matches));
+          base::WrapUnique(new password_manager::StubFormSaver), &fetcher_));
+  fetcher_.SetNonFederated(best_matches, 0u);
   return test_form_manager;
 }
 
 std::unique_ptr<password_manager::PasswordFormManager>
 ManagePasswordsUIControllerTest::CreateFormManager() {
-  std::vector<std::unique_ptr<autofill::PasswordForm>> stored_forms;
-  stored_forms.push_back(
-      base::MakeUnique<autofill::PasswordForm>(test_local_form()));
   return CreateFormManagerWithBestMatches(test_local_form(),
-                                          std::move(stored_forms));
+                                          {&test_local_form()});
 }
 
 void ManagePasswordsUIControllerTest::TestNotChangingStateOnAutofill(
     password_manager::ui::State state) {
   DCHECK(state == password_manager::ui::PENDING_PASSWORD_STATE ||
          state == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE ||
          state == password_manager::ui::CONFIRMATION_STATE);
 
   // Set the bubble state to |state|.
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
@@ skipping 61 matching lines @@
   EXPECT_EQ(test_local_form().origin, controller()->GetOrigin());
 
   ExpectIconStateIs(password_manager::ui::PENDING_PASSWORD_STATE);
 }
 
 TEST_F(ManagePasswordsUIControllerTest, BlacklistedFormPasswordSubmitted) {
   autofill::PasswordForm blacklisted;
   blacklisted.origin = test_local_form().origin;
   blacklisted.signon_realm = blacklisted.origin.spec();
   blacklisted.blacklisted_by_user = true;
-  std::vector<std::unique_ptr<autofill::PasswordForm>> stored_forms;
-  stored_forms.push_back(base::MakeUnique<autofill::PasswordForm>(blacklisted));
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager =
-      CreateFormManagerWithBestMatches(test_local_form(),
-                                       std::move(stored_forms));
+      CreateFormManagerWithBestMatches(test_local_form(), {&blacklisted});
   EXPECT_CALL(*controller(), OnUpdateBubbleAndIconVisibility());
   controller()->OnPasswordSubmitted(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             controller()->GetState());
   EXPECT_FALSE(controller()->opened_bubble());
 
   ExpectIconStateIs(password_manager::ui::PENDING_PASSWORD_STATE);
 }
 
 TEST_F(ManagePasswordsUIControllerTest, PasswordSubmittedBubbleSuppressed) {
   CreateSmartBubbleFieldTrial();
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   password_manager::InteractionsStats stats;
   stats.origin_domain = test_local_form().origin.GetOrigin();
   stats.username_value = test_local_form().username_value;
   stats.dismissal_count = kGreatDissmisalCount;
-  std::vector<std::unique_ptr<password_manager::InteractionsStats>>
-      interactions;
-  interactions.push_back(
-      base::MakeUnique<password_manager::InteractionsStats>(stats));
-  test_form_manager->OnGetSiteStatistics(std::move(interactions));
+  fetcher().set_stats({&stats});
   test_form_manager->ProvisionallySave(
       test_local_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   EXPECT_CALL(*controller(), OnUpdateBubbleAndIconVisibility());
   controller()->OnPasswordSubmitted(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             controller()->GetState());
   EXPECT_FALSE(controller()->opened_bubble());
   ASSERT_TRUE(controller()->GetCurrentInteractionStats());
   EXPECT_EQ(stats, *controller()->GetCurrentInteractionStats());
 
   ExpectIconStateIs(password_manager::ui::PENDING_PASSWORD_STATE);
   variations::testing::ClearAllVariationParams();
 }
 
 TEST_F(ManagePasswordsUIControllerTest, PasswordSubmittedBubbleNotSuppressed) {
   CreateSmartBubbleFieldTrial();
   std::unique_ptr<password_manager::PasswordFormManager> test_form_manager(
       CreateFormManager());
   password_manager::InteractionsStats stats;
   stats.origin_domain = test_local_form().origin.GetOrigin();
   stats.username_value = base::ASCIIToUTF16("not my username");
   stats.dismissal_count = kGreatDissmisalCount;
-  std::vector<std::unique_ptr<password_manager::InteractionsStats>>
-      interactions;
-  interactions.push_back(
-      base::MakeUnique<password_manager::InteractionsStats>(stats));
-  test_form_manager->OnGetSiteStatistics(std::move(interactions));
+  fetcher().set_stats({&stats});
   test_form_manager->ProvisionallySave(
       test_local_form(),
       password_manager::PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   EXPECT_CALL(*controller(), OnUpdateBubbleAndIconVisibility());
   controller()->OnPasswordSubmitted(std::move(test_form_manager));
   EXPECT_EQ(password_manager::ui::PENDING_PASSWORD_STATE,
             controller()->GetState());
   EXPECT_TRUE(controller()->opened_bubble());
   EXPECT_FALSE(controller()->GetCurrentInteractionStats());
 
@@ skipping 397 matching lines @@
   // Open the bubble again.
   local_credentials.emplace_back(new autofill::PasswordForm(test_local_form()));
   EXPECT_CALL(*controller(), OnUpdateBubbleAndIconVisibility());
   controller()->OnAutoSignin(std::move(local_credentials),
                              test_local_form().origin);
   EXPECT_EQ(password_manager::ui::AUTO_SIGNIN_STATE, controller()->GetState());
   // Check the delegate is destroyed. Thus, the first bubble has no way to mess
   // up with the controller's state.
   EXPECT_FALSE(proxy_delegate);
 }