Refactor CredentialManagerImpl::Get. It should use PasswordStore::GetLogins().

ios/chrome/browser/passwords/credential_manager_unittest.mm

 // 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 "ios/chrome/browser/passwords/credential_manager.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/mac/bind_objc_block.h"
@@ skipping 37 matching lines @@
                          credential:(const web::Credential&)credential
                   completionHandler:(void (^)(BOOL))completionHandler {
   static_cast<ResolvePromiseBlock>([self blockForSelector:_cmd])(requestID,
                                                                  credential);
   completionHandler(YES);
 }
 @end
 
 namespace {
 
+const char kTestURL[] = "https://foo.com/login";
+
 // Returns a test credential.
 autofill::PasswordForm GetTestPasswordForm1(bool zero_click_allowed) {
   autofill::PasswordForm form;
+  form.origin = GURL(kTestURL);
+  form.signon_realm = form.origin.spec();
   form.username_value = base::ASCIIToUTF16("foo");
   form.password_value = base::ASCIIToUTF16("bar");
   form.skip_zero_click = !zero_click_allowed;
   form.type = autofill::PasswordForm::Type::TYPE_API;
   return form;
 }
 
 // Returns a test credential matching |GetTestPasswordForm1()|.
 web::Credential GetTestWebCredential1(bool zero_click_allowed) {
   web::Credential credential;
   autofill::PasswordForm form(GetTestPasswordForm1(zero_click_allowed));
   credential.type = web::CredentialType::CREDENTIAL_TYPE_PASSWORD;
   credential.id = form.username_value;
   credential.password = form.password_value;
   return credential;
 }
 
 // Returns a different test credential.
 autofill::PasswordForm GetTestPasswordForm2(bool zero_click_allowed) {
   autofill::PasswordForm form;
+  form.origin = GURL(kTestURL);
+  form.signon_realm = form.origin.spec();
   form.username_value = base::ASCIIToUTF16("baz");
   form.password_value = base::ASCIIToUTF16("bah");
   form.skip_zero_click = !zero_click_allowed;
   return form;
 }
 
 // Returns a test credential matching |GetTestPasswordForm2()|.
 web::Credential GetTestWebCredential2(bool zero_click_allowed) {
   web::Credential credential;
   autofill::PasswordForm form(GetTestPasswordForm2(zero_click_allowed));
@@ skipping 92 matching lines @@
 
   void SetUp() override {
     web::WebTestWithWebState::SetUp();
     id originalMock =
         [OCMockObject niceMockForClass:[JSCredentialManager class]];
     mock_js_credential_manager_.reset([[MockJSCredentialManager alloc]
         initWithRepresentedObject:originalMock]);
     credential_manager_.reset(new CredentialManager(
         web_state(), &stub_client_, &stub_driver_,
         static_cast<id>(mock_js_credential_manager_.get())));
+    LoadHtml(@"", GURL(kTestURL));
   }
 
   // Sets up an expectation that the promise identified by |request_id| will be
   // resolved with |credential|. |verified| must point to a variable that will
   // be checked by the caller to ensure that the expectations were run. (This
   // is necessary because OCMock doesn't handle methods with C++ object
   // parameters.)
   void ExpectPromiseResolved(bool* verified,
                              int request_id,
                              const web::Credential& credential) {
     SEL selector =
         @selector(resolvePromiseWithRequestID:credential:completionHandler:);
     web::Credential strong_credential(credential);
     [mock_js_credential_manager_
                   onSelector:selector
         callBlockExpectation:^(NSInteger block_request_id,
                                const web::Credential& block_credential) {
           EXPECT_EQ(request_id, block_request_id);
-          EXPECT_TRUE(CredentialsEqual(strong_credential, block_credential));
+          EXPECT_EQ(strong_credential.type, block_credential.type);
+          EXPECT_EQ(strong_credential.id, block_credential.id);
+          EXPECT_EQ(strong_credential.name, block_credential.name);
+          EXPECT_EQ(strong_credential.avatar_url, block_credential.avatar_url);
+          EXPECT_EQ(strong_credential.password, block_credential.password);
+          EXPECT_EQ(strong_credential.federation_origin.Serialize(),
+                    block_credential.federation_origin.Serialize());
           *verified = true;
         }];
   }
 
   // Same as |ExpectPromiseResolved(bool*, int, const web::Credential&)| but
   // does not expect a credential to be passed.
   void ExpectPromiseResolved(int request_id) {
     [[[mock_js_credential_manager_ representedObject] expect]
         resolvePromiseWithRequestID:request_id
                   completionHandler:nil];
@@ skipping 42 matching lines @@
 // is unavailable.
 TEST_F(CredentialManagerTest, RequestRejectedWhenPasswordStoreUnavailable) {
   // Clear the password store.
   stub_client_.SetPasswordStore(nullptr);
 
   // Requesting a credential should reject the request with an error.
   const int request_id = 0;
   ExpectPromiseRejected(request_id,
                         kCredentialsPasswordStoreUnavailableErrorType,
                         kCredentialsPasswordStoreUnavailableErrorMessage);
-  credential_manager_->CredentialsRequested(request_id,
-                                            GURL("http://foo.com/login"), false,
+  credential_manager_->CredentialsRequested(request_id, GURL(kTestURL), false,
                                             std::vector<std::string>(), true);
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   EXPECT_OCMOCK_VERIFY([mock_js_credential_manager_ representedObject]);
 }
 
 // Tests that a credential request is rejected when another request is pending.
 TEST_F(CredentialManagerTest, RequestRejectedWhenExistingRequestIsPending) {
   // Set a password store, but prevent requests from completing.
   stub_client_.SetPasswordStore(new password_manager::TestPasswordStore);
 
   // Make an initial request. Don't pump the message loop, so that the task
   // doesn't complete. Expect the request to resolve with an empty credential
   // after the message loop is pumped.
   const int first_request_id = 0;
   bool first_verified = false;
   ExpectPromiseResolved(&first_verified, first_request_id, web::Credential());
-  credential_manager_->CredentialsRequested(first_request_id,
-                                            GURL("http://foo.com/login"), false,
-                                            std::vector<std::string>(), true);
+  credential_manager_->CredentialsRequested(first_request_id, GURL(kTestURL),
+                                            false, std::vector<std::string>(),
+                                            true);
 
   // Making a second request and then pumping the message loop should reject the
   // request with an error.
   const int second_request_id = 0;
   ExpectPromiseRejected(second_request_id, kCredentialsPendingRequestErrorType,
                         kCredentialsPendingRequestErrorMessage);
-  credential_manager_->CredentialsRequested(second_request_id,
-                                            GURL("http://foo.com/login"), false,
-                                            std::vector<std::string>(), true);
+  credential_manager_->CredentialsRequested(second_request_id, GURL(kTestURL),
+                                            false, std::vector<std::string>(),
+                                            true);
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   EXPECT_TRUE(first_verified);
   EXPECT_OCMOCK_VERIFY([mock_js_credential_manager_ representedObject]);
 }
 
 // Tests that a zero-click credential request is resolved properly with an empty
 // credential when zero-click sign-in is disabled.
 TEST_F(CredentialManagerTest,
        ZeroClickRequestResolvedWithEmptyCredentialWhenZeroClickSignInDisabled) {
   // Set a password store, but request a zero-click credential with zero-click
   // disabled.
   stub_client_.SetPasswordStore(new password_manager::TestPasswordStore);
   const bool zero_click = true;
   static_cast<TestingPrefServiceSimple*>(stub_client_.GetPrefs())
       ->SetUserPref(password_manager::prefs::kCredentialsEnableAutosignin,
                     new base::FundamentalValue(!zero_click));
 
   // Requesting a zero-click credential should immediately resolve the request
   // with an empty credential.
   const int request_id = 0;
   bool verified = false;
   ExpectPromiseResolved(&verified, request_id, web::Credential());
   credential_manager_->CredentialsRequested(
-      request_id, GURL("http://foo.com/login"), zero_click,
-      std::vector<std::string>(), true);
+      request_id, GURL(kTestURL), zero_click, std::vector<std::string>(), true);
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   EXPECT_TRUE(verified);
 }
 
 // Tests that a credential request is properly resolved with an empty credential
 // when no credentials are available.
 TEST_F(CredentialManagerTest,
        RequestResolvedWithEmptyCredentialWhenNoneAvailable) {
   // Set a password store with no credentials, enable zero-click, and request a
   // zero-click credential.
   stub_client_.SetPasswordStore(new password_manager::TestPasswordStore);
   const bool zero_click = true;
   static_cast<TestingPrefServiceSimple*>(stub_client_.GetPrefs())
       ->SetUserPref(password_manager::prefs::kCredentialsEnableAutosignin,
                     new base::FundamentalValue(zero_click));
 
   // Requesting a zero-click credential should try to retrieve PasswordForms
   // from the PasswordStore and resolve the request with an empty Credential
   // when none are found.
   const int request_id = 0;
   bool verified = false;
   ExpectPromiseResolved(&verified, request_id, web::Credential());
   credential_manager_->CredentialsRequested(
-      request_id, GURL("http://foo.com/login"), zero_click,
-      std::vector<std::string>(), true);
+      request_id, GURL(kTestURL), zero_click, std::vector<std::string>(), true);
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   EXPECT_TRUE(verified);
 }
 
 // Tests that a zero-click credential request properly resolves.
 TEST_F(CredentialManagerTest, ZeroClickRequestResolved) {
   // Set a password store with a credential, enable zero-click, and request a
   // zero-click credential.
@@ skipping 13 matching lines @@
           new base::FundamentalValue(true));
   WaitForBackgroundTasks();
 
   // Requesting a zero-click credential should retrieve a PasswordForm from the
   // PasswordStore and resolve the request with a corresponding Credential.
   const int request_id = 0;
   bool verified = false;
   ExpectPromiseResolved(&verified, request_id,
                         GetTestWebCredential1(zero_click));
   credential_manager_->CredentialsRequested(
-      request_id, GURL("http://foo.com/login"), zero_click,
-      std::vector<std::string>(), true);
+      request_id, GURL(kTestURL), zero_click, std::vector<std::string>(), true);
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   EXPECT_TRUE(verified);
 }
 
 // Tests that a credential request properly resolves.
 // TODO(crbug.com/598851): Reenabled this test.
 TEST_F(CredentialManagerTest, DISABLED_RequestResolved) {
   // Set a password store with two credentials and set a credential to be
   // returned by the PasswordManagerClient as if chosen by the user.
   scoped_refptr<password_manager::TestPasswordStore> store(
       new password_manager::TestPasswordStore);
   const bool zero_click = false;
   store->AddLogin(GetTestPasswordForm1(zero_click));
   store->AddLogin(GetTestPasswordForm2(zero_click));
   stub_client_.SetPasswordStore(store);
   stub_client_.SetUserChosenCredential(password_manager::CredentialInfo(
       GetTestPasswordForm2(zero_click),
       password_manager::CredentialType::CREDENTIAL_TYPE_PASSWORD));
   WaitForBackgroundTasks();
 
   // Request a credential. The request should be resolved with the credential
   // set on the stub client.
   const int request_id = 0;
   bool verified = false;
   ExpectPromiseResolved(&verified, request_id,
                         GetTestWebCredential2(zero_click));
   credential_manager_->CredentialsRequested(
-      request_id, GURL("http://foo.com/login"), zero_click,
-      std::vector<std::string>(), true);
+      request_id, GURL(kTestURL), zero_click, std::vector<std::string>(), true);
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   EXPECT_TRUE(verified);
 }
 
 // Tests that two requests back-to-back succeed when they wait to be resolved.
 // TODO(crbug.com/598851): Reenable this test.
 TEST_F(CredentialManagerTest, DISABLED_ConsecutiveRequestsResolve) {
   // Set a password store with two credentials and set a credential to be
   // returned by the PasswordManagerClient as if chosen by the user.
   scoped_refptr<password_manager::TestPasswordStore> store(
       new password_manager::TestPasswordStore);
   const bool zero_click = false;
   store->AddLogin(GetTestPasswordForm1(zero_click));
   stub_client_.SetPasswordStore(store);
   stub_client_.SetUserChosenCredential(password_manager::CredentialInfo(
       GetTestPasswordForm1(zero_click),
       password_manager::CredentialType::CREDENTIAL_TYPE_PASSWORD));
   WaitForBackgroundTasks();
 
   // Request a credential. The request should be resolved with the credential
   // set on the stub client.
   const int first_request_id = 0;
   bool first_verified = false;
   ExpectPromiseResolved(&first_verified, first_request_id,
                         GetTestWebCredential1(zero_click));
-  credential_manager_->CredentialsRequested(
-      first_request_id, GURL("http://foo.com/login"), zero_click,
-      std::vector<std::string>(), true);
+  credential_manager_->CredentialsRequested(first_request_id, GURL(kTestURL),
+                                            zero_click,
+                                            std::vector<std::string>(), true);
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   EXPECT_TRUE(first_verified);
 
   ClearPromiseResolutionExpectations();
 
   // Make a second request. It should be resolved again.
   const int second_request_id = 1;
   bool second_verified = false;
   ExpectPromiseResolved(&second_verified, second_request_id,
                         GetTestWebCredential1(zero_click));
-  credential_manager_->CredentialsRequested(
-      second_request_id, GURL("http://foo.com/login"), zero_click,
-      std::vector<std::string>(), true);
+  credential_manager_->CredentialsRequested(second_request_id, GURL(kTestURL),
+                                            zero_click,
+                                            std::vector<std::string>(), true);
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   EXPECT_TRUE(second_verified);
 }
 
 // Tests that notifySignedIn prompts the user to save a password.
 TEST_F(CredentialManagerTest,
        SignInResolvesAndPromptsUserWhenSavingEnabledAndNotBlacklisted) {
   // Set a password store so the PasswordFormManager can retrieve credentials.
   scoped_refptr<password_manager::TestPasswordStore> store(
       new password_manager::TestPasswordStore);
   stub_client_.SetPasswordStore(store);
   const bool saving_enabled = true;
   EXPECT_CALL(stub_client_, IsSavingAndFillingEnabledForCurrentPage())
       .WillOnce(Return(saving_enabled))
       .WillOnce(Return(saving_enabled));
 
   // Notify the browser that the user signed in.
   const int request_id = 0;
   ExpectPromiseResolved(request_id);
   const bool zero_click = true;
-  credential_manager_->SignedIn(request_id, GURL("http://foo.com/login"),
+  credential_manager_->SignedIn(request_id, GURL(kTestURL),
                                 GetTestWebCredential1(zero_click));
 
   // Pump the message loop and verify.
   WaitForBackgroundTasks();
   autofill::PasswordForm expected_observed_form(
       GetTestPasswordForm1(zero_click));
   expected_observed_form.username_value.clear();
   expected_observed_form.password_value.clear();
   EXPECT_EQ(expected_observed_form, stub_client_.saved_form()->observed_form());
 }
 
 // Tests that notifySignedIn doesn't prompt the user to save a password when the
 // password manager is disabled for the current page.
 TEST_F(CredentialManagerTest,
        SignInResolvesAndDoesNotPromptsUserWhenSavingDisabledAndNotBlacklisted) {
   // Disable saving.
   scoped_refptr<password_manager::TestPasswordStore> store(
       new password_manager::TestPasswordStore);
   stub_client_.SetPasswordStore(store);
   const bool saving_enabled = false;
   EXPECT_CALL(stub_client_, IsSavingAndFillingEnabledForCurrentPage())
       .WillOnce(Return(saving_enabled));
 
   // Notify the browser that the user signed in.
   const int request_id = 0;
   ExpectPromiseResolved(request_id);
   const bool zero_click = false;
-  credential_manager_->SignedIn(request_id, GURL("http://foo.com/login"),
+  credential_manager_->SignedIn(request_id, GURL(kTestURL),
                                 GetTestWebCredential1(zero_click));
 
   // Pump the message loop and verify that no form was saved.
   WaitForBackgroundTasks();
   EXPECT_FALSE(stub_client_.saved_form());
 }
 
 // Tests that notifySignedIn doesn't prompt the user to save a password when the
 // submitted form is blacklisted by the password manager.
 TEST_F(CredentialManagerTest,
@@ skipping 10 matching lines @@
   // Save the credential that will be signed in and mark it blacklisted.
   const bool zero_click = false;
   autofill::PasswordForm blacklisted_form(GetTestPasswordForm1(zero_click));
   blacklisted_form.blacklisted_by_user = true;
   store->AddLogin(blacklisted_form);
   WaitForBackgroundTasks();
 
   // Notify the browser that the user signed in.
   const int request_id = 0;
   ExpectPromiseResolved(request_id);
-  credential_manager_->SignedIn(request_id, GURL("http://foo.com/login"),
+  credential_manager_->SignedIn(request_id, GURL(kTestURL),
                                 GetTestWebCredential1(zero_click));
 
   // Pump the message loop and verify that no form was saved.
   WaitForBackgroundTasks();
   EXPECT_FALSE(stub_client_.saved_form());
 }
 
 // Tests that notifySignedOut marks credentials as non-zero-click.
 TEST_F(CredentialManagerTest, SignOutResolvesAndMarksFormsNonZeroClick) {
   // Create two zero-click credentials for the current page.
@@ skipping 35 matching lines @@
   WaitForBackgroundTasks();
   EXPECT_EQ(1U, store->stored_passwords().size());
   const std::vector<autofill::PasswordForm>& passwords_after_signout =
       store->stored_passwords().find(current_origin)->second;
   EXPECT_EQ(2U, passwords_after_signout.size());
   for (const autofill::PasswordForm& form : passwords_after_signout)
     EXPECT_TRUE(form.skip_zero_click);
 }
 
 }  // namespace