Save federated credential's signon_realm in the correct format.

components/password_manager/content/browser/credential_manager_impl_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 "components/password_manager/content/browser/credential_manager_impl.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <tuple>
@@ skipping 199 matching lines @@
     ON_CALL(*client_, IsSavingAndFillingEnabledForCurrentPage())
         .WillByDefault(testing::Return(true));
     ON_CALL(*client_, IsOffTheRecord()).WillByDefault(testing::Return(false));
     ON_CALL(*client_, DidLastPageLoadEncounterSSLErrors())
         .WillByDefault(testing::Return(false));
 
     NavigateAndCommit(GURL("https://example.com/test.html"));
 
     form_.username_value = base::ASCIIToUTF16("Username");
     form_.display_name = base::ASCIIToUTF16("Display Name");
+    form_.icon_url = GURL("https://example.com/icon.png");
     form_.password_value = base::ASCIIToUTF16("Password");
     form_.origin = web_contents()->GetLastCommittedURL().GetOrigin();
     form_.signon_realm = form_.origin.spec();
     form_.scheme = autofill::PasswordForm::SCHEME_HTML;
     form_.skip_zero_click = false;
     form_.ssl_valid = true;
 
     affiliated_form1_.username_value = base::ASCIIToUTF16("Affiliated 1");
     affiliated_form1_.display_name = base::ASCIIToUTF16("Display Name");
     affiliated_form1_.password_value = base::ASCIIToUTF16("Password");
@@ skipping 177 matching lines @@
   EXPECT_TRUE(called);
   EXPECT_TRUE(client_->pending_manager()->HasCompletedMatching());
 
   autofill::PasswordForm new_form =
       client_->pending_manager()->pending_credentials();
   EXPECT_EQ(form_.username_value, new_form.username_value);
   EXPECT_EQ(form_.display_name, new_form.display_name);
   EXPECT_EQ(form_.password_value, new_form.password_value);
   EXPECT_EQ(form_.origin, new_form.origin);
   EXPECT_EQ(form_.signon_realm, new_form.signon_realm);
+  EXPECT_TRUE(new_form.federation_origin.unique());
+  EXPECT_EQ(form_.icon_url, new_form.icon_url);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, new_form.scheme);
 }
 
+TEST_F(CredentialManagerImplTest, CredentialManagerOnStoreFederated) {
+  EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
+                            _, CredentialSourceType::CREDENTIAL_SOURCE_API))
+      .Times(testing::Exactly(1));
+  EXPECT_CALL(*client_, NotifyStorePasswordCalled());
+
+  bool called = false;
+  form_.federation_origin = url::Origin(GURL("https://google.com/"));
+  form_.password_value = base::string16();
+  form_.signon_realm = "federation://example.com/google.com";
+  CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_FEDERATED);
+  CallStore(info, base::Bind(&RespondCallback, &called));
+
+  // Allow the PasswordFormManager to talk to the password store, determine
+  // that the form is new, and set it as pending.
+  RunAllPendingTasks();
+
+  EXPECT_TRUE(called);
+  EXPECT_TRUE(client_->pending_manager()->HasCompletedMatching());
+
+  autofill::PasswordForm new_form =
+      client_->pending_manager()->pending_credentials();
+  EXPECT_EQ(form_.username_value, new_form.username_value);
+  EXPECT_EQ(form_.display_name, new_form.display_name);
+  EXPECT_EQ(form_.password_value, new_form.password_value);
+  EXPECT_EQ(form_.origin, new_form.origin);
+  EXPECT_EQ(form_.signon_realm, new_form.signon_realm);
+  EXPECT_EQ(form_.federation_origin, new_form.federation_origin);
+  EXPECT_EQ(form_.icon_url, new_form.icon_url);
+  EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, new_form.scheme);
+}
+
 TEST_F(CredentialManagerImplTest, CredentialManagerStoreOverwrite) {
   // Populate the PasswordStore with a form.
   store_->AddLogin(form_);
   RunAllPendingTasks();
 
   // Calling 'Store' with a credential that matches |form_| should update
   // the password without prompting the user.
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   info.password = base::ASCIIToUTF16("Totally new password.");
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(_, _)).Times(0);
@@ skipping 39 matching lines @@
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerFederatedStoreOverwriteZeroClick) {
   // Set the global zero click flag on, and populate the PasswordStore with a
   // form that's set to skip zero click.
   client_->set_zero_click_enabled(true);
   client_->set_first_run_seen(true);
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
+  form_.password_value = base::string16();
   form_.skip_zero_click = true;
   form_.signon_realm = "federation://example.com/example.com";
   store_->AddLogin(form_);
   RunAllPendingTasks();
 
   // Calling 'Store' with a credential that matches |form_| should update
   // the credential without prompting the user.
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_FEDERATED);
   bool called = false;
   EXPECT_CALL(*client_, NotifyStorePasswordCalled());
@@ skipping 244 matching lines @@
   std::vector<GURL> federations;
 
   EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
 
   ExpectZeroClickSignInFailure(true, false, federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialFederatedMatch) {
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
+  form_.password_value = base::string16();
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://example.com/"));
 
   EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
 
   ExpectZeroClickSignInSuccess(true, true, federations,
                                mojom::CredentialType::FEDERATED);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialFederatedNoMatch) {
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
+  form_.password_value = base::string16();
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://not-example.com/"));
 
   EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
 
   ExpectZeroClickSignInFailure(true, true, federations);
 }
@@ skipping 34 matching lines @@
 
   // We pass in 'false' for the 'include_passwords' argument to ensure that
   // password-type credentials are excluded as potential matches.
   ExpectZeroClickSignInFailure(true, false, federations);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialAffiliatedFederatedMatch) {
   affiliated_form1_.federation_origin =
       url::Origin(GURL("https://example.com/"));
+  affiliated_form1_.password_value = base::string16();
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
   auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://example.com/"));
 
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           cm_service_impl_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
   ExpectZeroClickSignInSuccess(true, true, federations,
                                mojom::CredentialType::FEDERATED);
 }
 
 TEST_F(CredentialManagerImplTest,
        CredentialManagerOnRequestCredentialAffiliatedFederatedNoMatch) {
   affiliated_form1_.federation_origin =
       url::Origin(GURL("https://example.com/"));
+  affiliated_form1_.password_value = base::string16();
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
   auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://not-example.com/"));
 
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
@@ skipping 341 matching lines @@
   blacklisted.origin = form_.origin;
   blacklisted.signon_realm = form_.signon_realm;
   blacklisted.type = autofill::PasswordForm::TYPE_API;
   blacklisted.ssl_valid = true;
   blacklisted.date_created = passwords[form_.signon_realm][0].date_created;
   EXPECT_THAT(passwords[form_.signon_realm], testing::ElementsAre(blacklisted));
 }
 
 TEST_F(CredentialManagerImplTest, BlacklistFederatedCredential) {
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
+  form_.password_value = base::string16();
   form_.signon_realm = "federation://example.com/example.com";
 
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API));
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_FEDERATED);
   bool called = false;
   CallStore(info, base::Bind(&RespondCallback, &called));
   // Allow the PasswordFormManager to talk to the password store
   RunAllPendingTasks();
 
@@ skipping 39 matching lines @@
 
 TEST_F(CredentialManagerImplTest, RespectBlacklistingFederatedCredential) {
   autofill::PasswordForm blacklisted;
   blacklisted.blacklisted_by_user = true;
   blacklisted.origin = form_.origin;
   blacklisted.signon_realm = blacklisted.origin.spec();
   blacklisted.ssl_valid = true;
   store_->AddLogin(blacklisted);
 
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
+  form_.password_value = base::string16();
   form_.signon_realm = "federation://example.com/example.com";
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_FEDERATED);
   bool called = false;
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API));
   CallStore(info, base::Bind(&RespondCallback, &called));
   // Allow the PasswordFormManager to talk to the password store
   RunAllPendingTasks();
 
   ASSERT_TRUE(client_->pending_manager());
   EXPECT_TRUE(client_->pending_manager()->IsBlacklisted());
 }
 
 }  // namespace password_manager