CREDENTIAL: Tighten the behavior of 'requireUserMediation()'

components/password_manager/content/browser/credential_manager_dispatcher_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_dispatcher.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <tuple>
@@ skipping 220 matching lines @@
     affiliated_form2_.ssl_valid = true;
 
     origin_path_form_.username_value = base::ASCIIToUTF16("Username 2");
     origin_path_form_.display_name = base::ASCIIToUTF16("Display Name 2");
     origin_path_form_.password_value = base::ASCIIToUTF16("Password 2");
     origin_path_form_.origin = GURL("https://example.com/path");
     origin_path_form_.signon_realm = origin_path_form_.origin.spec();
     origin_path_form_.scheme = autofill::PasswordForm::SCHEME_HTML;
     origin_path_form_.skip_zero_click = false;
 
+    subdomain_form_.username_value = base::ASCIIToUTF16("Username 2");
+    subdomain_form_.display_name = base::ASCIIToUTF16("Display Name 2");
+    subdomain_form_.password_value = base::ASCIIToUTF16("Password 2");
+    subdomain_form_.origin = GURL("https://subdomain.example.com/path");
+    subdomain_form_.signon_realm = subdomain_form_.origin.spec();
+    subdomain_form_.scheme = autofill::PasswordForm::SCHEME_HTML;
+    subdomain_form_.skip_zero_click = false;
+
     cross_origin_form_.username_value = base::ASCIIToUTF16("Username");
     cross_origin_form_.display_name = base::ASCIIToUTF16("Display Name");
     cross_origin_form_.password_value = base::ASCIIToUTF16("Password");
     cross_origin_form_.origin = GURL("https://example.net/");
     cross_origin_form_.signon_realm = cross_origin_form_.origin.spec();
     cross_origin_form_.scheme = autofill::PasswordForm::SCHEME_HTML;
     cross_origin_form_.skip_zero_click = false;
 
     store_->Clear();
     EXPECT_TRUE(store_->IsEmpty());
@@ skipping 41 matching lines @@
     EXPECT_EQ(type, std::get<1>(send_param).type);
   }
 
   CredentialManagerDispatcher* dispatcher() { return dispatcher_.get(); }
 
  protected:
   autofill::PasswordForm form_;
   autofill::PasswordForm affiliated_form1_;
   autofill::PasswordForm affiliated_form2_;
   autofill::PasswordForm origin_path_form_;
+  autofill::PasswordForm subdomain_form_;
   autofill::PasswordForm cross_origin_form_;
   scoped_refptr<TestPasswordStore> store_;
   std::unique_ptr<testing::NiceMock<MockPasswordManagerClient>> client_;
   std::unique_ptr<SlightlyLessStubbyPasswordManagerDriver> stub_driver_;
   std::unique_ptr<CredentialManagerDispatcher> dispatcher_;
 };
 
 TEST_F(CredentialManagerDispatcherTest, IsZeroClickAllowed) {
   // IsZeroClickAllowed is uneffected by the first-run status.
   client_->set_zero_click_enabled(true);
@@ skipping 178 matching lines @@
   process()->sink().ClearMessages();
 
   RunAllPendingTasks();
 
   EXPECT_FALSE(client_->pending_manager());
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequireUserMediation) {
   store_->AddLogin(form_);
+  store_->AddLogin(subdomain_form_);
   store_->AddLogin(cross_origin_form_);
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
-  EXPECT_EQ(2U, passwords.size());
+  EXPECT_EQ(3U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
+  EXPECT_EQ(1U, passwords[subdomain_form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
+  EXPECT_FALSE(passwords[subdomain_form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
 
   dispatcher()->OnRequireUserMediation(kRequestId);
   RunAllPendingTasks();
 
   const uint32_t kMsgID =
       CredentialManagerMsg_AcknowledgeRequireUserMediation::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 
   passwords = store_->stored_passwords();
-  EXPECT_EQ(2U, passwords.size());
+  EXPECT_EQ(3U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
+  EXPECT_EQ(1U, passwords[subdomain_form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_TRUE(passwords[form_.signon_realm][0].skip_zero_click);
+  EXPECT_TRUE(passwords[subdomain_form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequireUserMediationIncognito) {
   EXPECT_CALL(*client_, IsOffTheRecord()).WillRepeatedly(testing::Return(true));
   store_->AddLogin(form_);
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
@@ skipping 647 matching lines @@
 TEST_F(CredentialManagerDispatcherTest, GetSynthesizedFormForOrigin) {
   autofill::PasswordForm synthesized =
       dispatcher_->GetSynthesizedFormForOrigin();
   EXPECT_EQ(kTestWebOrigin, synthesized.origin.spec());
   EXPECT_EQ(kTestWebOrigin, synthesized.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, synthesized.scheme);
   EXPECT_TRUE(synthesized.ssl_valid);
 }
 
 }  // namespace password_manager