Autofill: Refactoring to support fetching password after a username is selected

components/password_manager/core/browser/password_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 <vector>
 
 #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/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/password_manager/core/browser/mock_password_store.h"
+#include "components/password_manager/core/browser/password_autofill_manager.h"
 #include "components/password_manager/core/browser/password_manager.h"
 #include "components/password_manager/core/browser/password_manager_driver.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/browser/stub_password_manager_client.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class PasswordGenerationManager;
 
@@ skipping 26 matching lines @@
  public:
   MOCK_METHOD1(FillPasswordForm, void(const autofill::PasswordFormFillData&));
   MOCK_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
   MOCK_METHOD0(IsOffTheRecord, bool());
   MOCK_METHOD0(GetPasswordGenerationManager, PasswordGenerationManager*());
   MOCK_METHOD0(GetPasswordManager, PasswordManager*());
   MOCK_METHOD0(GetAutofillManager, autofill::AutofillManager*());
   MOCK_METHOD1(AllowPasswordGenerationForForm, void(autofill::PasswordForm*));
   MOCK_METHOD1(AccountCreationFormsFound,
                void(const std::vector<autofill::FormData>&));
+  MOCK_METHOD2(AcceptPasswordAutofillSuggestion,
+               void(const base::string16&, const base::string16&));
+  MOCK_METHOD0(GetPasswordAutofillManager, PasswordAutofillManager*());
 };
 
 ACTION_P(InvokeConsumer, forms) { arg0->OnGetPasswordStoreResults(forms); }
 
 ACTION_P(SaveToScopedPtr, scoped) { scoped->reset(arg0); }
 
 class TestPasswordManager : public PasswordManager {
  public:
   explicit TestPasswordManager(PasswordManagerClient* client)
       : PasswordManager(client) {}
   virtual ~TestPasswordManager() {}
 
-  virtual void OnPasswordFormSubmitted(const PasswordForm& form) OVERRIDE {
-    PasswordManager::OnPasswordFormSubmitted(form);
-  }
-
  private:
   DISALLOW_COPY_AND_ASSIGN(TestPasswordManager);
 };
 
 }  // namespace
 
 class PasswordManagerTest : public testing::Test {
  protected:
   virtual void SetUp() {
     prefs_.registry()->RegisterBooleanPref(prefs::kPasswordManagerEnabled,
                                            true);
 
     store_ = new MockPasswordStore;
     CHECK(store_->Init(syncer::SyncableService::StartSyncFlare()));
 
     EXPECT_CALL(client_, GetPasswordStore()).WillRepeatedly(Return(store_));
     EXPECT_CALL(client_, GetPrefs()).WillRepeatedly(Return(&prefs_));
     EXPECT_CALL(client_, GetDriver()).WillRepeatedly(Return(&driver_));
 
     manager_.reset(new TestPasswordManager(&client_));
+    password_autofill_manager_.reset(
+        new PasswordAutofillManager(&client_, NULL));
 
     EXPECT_CALL(driver_, DidLastPageLoadEncounterSSLErrors())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(driver_, IsOffTheRecord()).WillRepeatedly(Return(false));
     EXPECT_CALL(driver_, GetPasswordGenerationManager())
         .WillRepeatedly(Return(static_cast<PasswordGenerationManager*>(NULL)));
     EXPECT_CALL(driver_, GetPasswordManager())
         .WillRepeatedly(Return(manager_.get()));
     EXPECT_CALL(driver_, AllowPasswordGenerationForForm(_)).Times(AnyNumber());
+    EXPECT_CALL(driver_, GetPasswordAutofillManager())
+        .WillRepeatedly(Return(password_autofill_manager_.get()));
 
     EXPECT_CALL(*store_, ReportMetricsImpl()).Times(AnyNumber());
   }
 
   virtual void TearDown() {
     store_->Shutdown();
     store_ = NULL;
   }
 
   PasswordForm MakeSimpleForm() {
@@ skipping 76 matching lines @@
   }
 
   void FormSubmitted(const autofill::PasswordForm& form) {
     submitted_form_ = form;
   }
 
   TestingPrefServiceSimple prefs_;
   scoped_refptr<MockPasswordStore> store_;
   MockPasswordManagerClient client_;
   MockPasswordManagerDriver driver_;
+  scoped_ptr<PasswordAutofillManager> password_autofill_manager_;
   scoped_ptr<TestPasswordManager> manager_;
   PasswordForm submitted_form_;
 };
 
 MATCHER_P(FormMatches, form, "") {
   return form.signon_realm == arg.signon_realm && form.origin == arg.origin &&
          form.action == arg.action &&
          form.username_element == arg.username_element &&
          form.password_element == arg.password_element &&
          form.password_autocomplete_set == arg.password_autocomplete_set &&
@@ skipping 387 matching lines @@
   PasswordForm failed_login_form(MakeTwitterFailedLoginForm());
   observed.clear();
   observed.push_back(failed_login_form);
   // A PasswordForm appears, and is visible in the layout:
   // No expected calls to the PasswordStore...
   manager()->OnPasswordFormsParsed(observed);
   manager()->OnPasswordFormsRendered(observed);
 }
 
 }  // namespace password_manager