[password generation] Always allow generated passwords to be shown.

chrome/browser/password_manager/password_form_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 32 matching lines @@
 
 class TestPasswordManager : public PasswordManager {
  public:
   explicit TestPasswordManager(PasswordManagerDelegate* delegate)
       : PasswordManager(NULL, delegate) {}
 
   virtual void Autofill(
       const autofill::PasswordForm& form_for_autofill,
       const autofill::PasswordFormMap& best_matches,
       const autofill::PasswordForm& preferred_match,
-      bool wait_for_username) const OVERRIDE {}
+      bool wait_for_username) const OVERRIDE {
+    best_matches_ = best_matches;
+  }
+
+  autofill::PasswordFormMap GetLatestBestMatches() { return best_matches_; }

[Ilya Sherman, 2013/09/19 01:02:20]

Return by const-ref?

[Garrett Casto, 2013/09/19 17:40:14]

I'm generally wary of returning references as it complicates lifetime issues,
but it's fine here. Changed.

+
+ private:
+  // Marked mutable to get around constness of Autofill().

[Ilya Sherman, 2013/09/19 01:02:20]

Hmm, it's rather odd for the Autofill() method to be const in the first place. 
There are definitely externally-observable results from calling it...  Oh well,
not really something that's necessarily ripe for addressing in this particular
CL.

[Garrett Casto, 2013/09/19 17:40:14]

Yeah, I had a similar thought as I was writing this.

+  mutable autofill::PasswordFormMap best_matches_;
 };
 
 }  // namespace
 
 class TestPasswordFormManager : public PasswordFormManager {
  public:
   TestPasswordFormManager(Profile* profile,
                           PasswordManager* manager,
                           const autofill::PasswordForm& observed_form,
                           bool ssl_valid)
@@ skipping 442 matching lines @@
   // message.
   manager.reset(new TestPasswordFormManager(
       profile(), &password_manager, *observed_form(), false));
   SimulateFetchMatchingLoginsFromPasswordStore(manager.get());
   result.clear();
   result.push_back(CreateSavedMatch(true));
   SimulateResponseFromPasswordStore(manager.get(), result);
   EXPECT_EQ(0u, manager->num_sent_messages());
 }
 
+TEST_F(PasswordFormManagerTest, TestForceInclusionOfGeneratedPasswords) {
+  TestPasswordManagerDelegate delegate(profile());
+  TestPasswordManager password_manager(&delegate);
+  scoped_ptr<TestPasswordFormManager> manager(new TestPasswordFormManager(
+      profile(), &password_manager, *observed_form(), false));
+
+  // Simulate having two matches for this origin, one of which was from a form
+  // with different HTML tags for elements. Because of scoring differences,
+  // only the first form will be sent to Autofill().
+  std::vector<PasswordForm*> results;
+  results.push_back(CreateSavedMatch(false));
+  results.push_back(CreateSavedMatch(false));
+  results[1]->username_value = ASCIIToUTF16("other@gmail.com");
+  results[1]->password_element = ASCIIToUTF16("signup_password");
+  results[1]->username_element = ASCIIToUTF16("signup_username");
+  SimulateFetchMatchingLoginsFromPasswordStore(manager.get());
+  SimulateResponseFromPasswordStore(manager.get(), results);
+  autofill::PasswordFormMap best_matches =
+      password_manager.GetLatestBestMatches();
+  EXPECT_EQ(1u, best_matches.size());
+  results.clear();
+
+  // Same thing, except this time the credentials that don't match quite as
+  // well are generated. They should now be sent to Autofill().
+  manager.reset(new TestPasswordFormManager(
+      profile(), &password_manager, *observed_form(), false));
+  results.push_back(CreateSavedMatch(false));
+  results.push_back(CreateSavedMatch(false));
+  results[1]->username_value = ASCIIToUTF16("other@gmail.com");
+  results[1]->password_element = ASCIIToUTF16("signup_password");
+  results[1]->username_element = ASCIIToUTF16("signup_username");
+  results[1]->type = PasswordForm::TYPE_GENERATED;
+  SimulateFetchMatchingLoginsFromPasswordStore(manager.get());
+  SimulateResponseFromPasswordStore(manager.get(), results);
+  EXPECT_EQ(2u, password_manager.GetLatestBestMatches().size());
+}
+
 TEST_F(PasswordFormManagerTest, TestSanitizePossibleUsernames) {
   scoped_ptr<PasswordFormManager> manager(new PasswordFormManager(
       profile(), NULL, NULL, *observed_form(), false));
   PasswordForm credentials(*observed_form());
   credentials.other_possible_usernames.push_back(ASCIIToUTF16("543-43-1234"));
   credentials.other_possible_usernames.push_back(
       ASCIIToUTF16("378282246310005"));
   credentials.other_possible_usernames.push_back(
       ASCIIToUTF16("other username"));
   credentials.username_value = ASCIIToUTF16("test@gmail.com");
@@ skipping 15 matching lines @@
 
   SanitizePossibleUsernames(manager.get(), &credentials);
 
   // SSN, duplicate in |other_possible_usernames| and duplicate of
   // |username_value| all removed.
   expected.clear();
   expected.push_back(ASCIIToUTF16("duplicate"));
   expected.push_back(ASCIIToUTF16("random"));
   EXPECT_THAT(credentials.other_possible_usernames, Eq(expected));
 }