[Password Manager Cleanup] Replaces NULL -> nullptr.

components/password_manager/core/browser/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 "base/memory/scoped_ptr.h"
 #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/run_loop.h"
@@ skipping 282 matching lines @@
   // Necessary for callbacks, and for TestAutofillDriver.
   base::MessageLoop message_loop;
 
   PasswordForm observed_form_;
   PasswordForm saved_match_;
   scoped_refptr<NiceMock<MockPasswordStore>> mock_store_;
   scoped_ptr<TestPasswordManagerClient> client_;
 };
 
 TEST_F(PasswordFormManagerTest, TestNewLogin) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
   SimulateMatchingPhase(&manager, RESULT_NO_MATCH);
 
   // User submits credentials for the observed form.
   PasswordForm credentials = *observed_form();
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = saved_match()->password_value;
   credentials.preferred = true;
   manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
@@ skipping 41 matching lines @@
   EXPECT_TRUE(GetPendingCredentials(&manager)->new_password_element.empty());
   EXPECT_TRUE(GetPendingCredentials(&manager)->new_password_value.empty());
 }
 
 // If PSL-matched credentials had been suggested, but the user has overwritten
 // the password, the provisionally saved credentials should no longer be
 // considered as PSL-matched, so that the exception for not prompting before
 // saving PSL-matched credentials should no longer apply.
 TEST_F(PasswordFormManagerTest,
        OverriddenPSLMatchedCredentialsNotMarkedAsPSLMatched) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   // The suggestion needs to be PSL-matched.
   saved_match()->original_signon_realm = "www.example.org";
   SimulateMatchingPhase(&manager, RESULT_MATCH_FOUND);
 
   // User modifies the suggested password and submits the form.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value =
@@ skipping 42 matching lines @@
   actual_saved_form.date_created = base::Time();
   EXPECT_EQ(expected_saved_form, actual_saved_form);
 }
 
 TEST_F(PasswordFormManagerTest, TestNewLoginFromNewPasswordElement) {
   // Add a new password field to the test form. The PasswordFormManager should
   // save the password from this field, instead of the current password field.
   observed_form()->new_password_element = ASCIIToUTF16("NewPasswd");
   observed_form()->username_marked_by_site = true;
 
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
   SimulateMatchingPhase(&manager, RESULT_NO_MATCH);
 
   // User enters current and new credentials to the observed form.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = saved_match()->password_value;
   credentials.new_password_value = ASCIIToUTF16("newpassword");
   credentials.preferred = true;
   manager.ProvisionallySave(
@@ skipping 17 matching lines @@
   EXPECT_EQ(credentials.new_password_value,
             GetPendingCredentials(&manager)->password_value);
   EXPECT_TRUE(GetPendingCredentials(&manager)->password_element.empty());
   EXPECT_TRUE(GetPendingCredentials(&manager)->new_password_element.empty());
   EXPECT_TRUE(GetPendingCredentials(&manager)->new_password_value.empty());
 }
 
 TEST_F(PasswordFormManagerTest, TestUpdatePassword) {
   // Create a PasswordFormManager with observed_form, as if we just
   // saw this form and need to find matching logins.
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   SimulateMatchingPhase(&manager, RESULT_MATCH_FOUND);
 
   // User submits credentials for the observed form using a username previously
   // stored, but a new password. Note that the observed form may have different
   // origin URL (as it does in this case) than the saved_match, but we want to
   // make sure the updated password is reflected in saved_match, because that is
   // what we autofilled.
   base::string16 new_pass = ASCIIToUTF16("test2");
@@ skipping 28 matching lines @@
   // Given that |observed_form| was most likely a change password form, it
   // should not serve as a source for updating meta-information stored with the
   // old credentials, such as element names, as they are likely going to be
   // different between change password and login forms. To test this in depth,
   // forcibly wipe |submit_element|, which should normally trigger updating this
   // field from |observed_form| in the UpdateLogin() step as a special case. We
   // will verify in the end that this did not happen.
   saved_match()->submit_element.clear();
 
   TestPasswordManagerClient client_with_store(mock_store());
-  PasswordFormManager manager(NULL, &client_with_store,
+  PasswordFormManager manager(nullptr, &client_with_store,
                               client_with_store.driver(), *observed_form(),
                               false);
   SimulateMatchingPhase(&manager, RESULT_MATCH_FOUND);
 
   // User submits current and new credentials to the observed form.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = saved_match()->password_value;
   credentials.new_password_value = ASCIIToUTF16("test2");
   credentials.preferred = true;
@@ skipping 21 matching lines @@
   Mock::VerifyAndClearExpectations(mock_store());
 
   // No meta-information should be updated, only the password.
   EXPECT_EQ(credentials.new_password_value, new_credentials.password_value);
   EXPECT_EQ(saved_match()->username_element, new_credentials.username_element);
   EXPECT_EQ(saved_match()->password_element, new_credentials.password_element);
   EXPECT_EQ(saved_match()->submit_element, new_credentials.submit_element);
 }
 
 TEST_F(PasswordFormManagerTest, TestIgnoreResult) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   // Make sure we don't match a PasswordForm if it was originally saved on
   // an SSL-valid page and we are now on a page with invalid certificate.
   saved_match()->ssl_valid = true;
   EXPECT_TRUE(IgnoredResult(&manager, saved_match()));
 
   saved_match()->ssl_valid = false;
   // Different paths for action / origin are okay.
   saved_match()->action = GURL("http://www.google.com/b/Login");
   saved_match()->origin = GURL("http://www.google.com/foo");
   EXPECT_FALSE(IgnoredResult(&manager, saved_match()));
 
   // Results should be ignored if the client requests it.
   client()->SetFormToFilter(*saved_match());
   EXPECT_TRUE(IgnoredResult(&manager, saved_match()));
 }
 
 TEST_F(PasswordFormManagerTest, TestEmptyAction) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   saved_match()->action = GURL();
   SimulateMatchingPhase(&manager, RESULT_MATCH_FOUND);
   // User logs in with the autofilled username / password from saved_match.
   PasswordForm login = *observed_form();
   login.username_value = saved_match()->username_value;
   login.password_value = saved_match()->password_value;
   manager.ProvisionallySave(
       login, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   EXPECT_FALSE(manager.IsNewLogin());
   // We bless our saved PasswordForm entry with the action URL of the
   // observed form.
   EXPECT_EQ(observed_form()->action, GetPendingCredentials(&manager)->action);
 }
 
 TEST_F(PasswordFormManagerTest, TestUpdateAction) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   SimulateMatchingPhase(&manager, RESULT_MATCH_FOUND);
   // User logs in with the autofilled username / password from saved_match.
   PasswordForm login = *observed_form();
   login.username_value = saved_match()->username_value;
   login.password_value = saved_match()->password_value;
 
   manager.ProvisionallySave(
       login, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   EXPECT_FALSE(manager.IsNewLogin());
   // The observed action URL is different from the previously saved one, and
   // is the same as the one that would be submitted on successful login.
   EXPECT_NE(observed_form()->action, saved_match()->action);
   EXPECT_EQ(observed_form()->action, GetPendingCredentials(&manager)->action);
 }
 
 TEST_F(PasswordFormManagerTest, TestDynamicAction) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   SimulateMatchingPhase(&manager, RESULT_NO_MATCH);
   PasswordForm login(*observed_form());
   // The submitted action URL is different from the one observed on page load.
   GURL new_action = GURL("http://www.google.com/new_action");
   login.action = new_action;
 
   manager.ProvisionallySave(
       login, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
@@ skipping 79 matching lines @@
   credentials.scheme = PasswordForm::SCHEME_HTML;
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = saved_match()->password_value;
 
   // An alternate version of the form that also has a new_password_element.
   PasswordForm new_credentials(*observed_form());
   new_credentials.new_password_element = ASCIIToUTF16("NewPasswd");
   new_credentials.new_password_value = ASCIIToUTF16("test1new");
 
   // Form with both username_element and password_element.
-  PasswordFormManager manager1(NULL, NULL, kNoDriver, credentials, false);
+  PasswordFormManager manager1(nullptr, nullptr, kNoDriver, credentials, false);
   SimulateMatchingPhase(&manager1, RESULT_NO_MATCH);
   EXPECT_TRUE(manager1.HasValidPasswordForm());
 
   // Form with username_element, password_element, and new_password_element.
-  PasswordFormManager manager2(NULL, NULL, kNoDriver, new_credentials, false);
+  PasswordFormManager manager2(nullptr, nullptr, kNoDriver, new_credentials,
+                               false);
   SimulateMatchingPhase(&manager2, RESULT_NO_MATCH);
   EXPECT_TRUE(manager2.HasValidPasswordForm());
 
   // Form with username_element and only new_password_element.
   new_credentials.password_element.clear();
-  PasswordFormManager manager3(NULL, NULL, kNoDriver, new_credentials, false);
+  PasswordFormManager manager3(nullptr, nullptr, kNoDriver, new_credentials,
+                               false);
   SimulateMatchingPhase(&manager3, RESULT_NO_MATCH);
   EXPECT_TRUE(manager3.HasValidPasswordForm());
 
   // Form without a username_element but with a password_element.
   credentials.username_element.clear();
-  PasswordFormManager manager4(NULL, NULL, kNoDriver, credentials, false);
+  PasswordFormManager manager4(nullptr, nullptr, kNoDriver, credentials, false);
   SimulateMatchingPhase(&manager4, RESULT_NO_MATCH);
   EXPECT_TRUE(manager4.HasValidPasswordForm());
 
   // Form without a username_element but with a new_password_element.
   new_credentials.username_element.clear();
-  PasswordFormManager manager5(NULL, NULL, kNoDriver, new_credentials, false);
+  PasswordFormManager manager5(nullptr, nullptr, kNoDriver, new_credentials,
+                               false);
   SimulateMatchingPhase(&manager5, RESULT_NO_MATCH);
   EXPECT_TRUE(manager5.HasValidPasswordForm());
 
   // Form without a password_element but with a username_element.
   credentials.username_element = saved_match()->username_element;
   credentials.password_element.clear();
-  PasswordFormManager manager6(NULL, NULL, kNoDriver, credentials, false);
+  PasswordFormManager manager6(nullptr, nullptr, kNoDriver, credentials, false);
   SimulateMatchingPhase(&manager6, RESULT_NO_MATCH);
   EXPECT_FALSE(manager6.HasValidPasswordForm());
 
   // Form with neither a password_element nor a username_element.
   credentials.username_element.clear();
   credentials.password_element.clear();
-  PasswordFormManager manager7(NULL, NULL, kNoDriver, credentials, false);
+  PasswordFormManager manager7(nullptr, nullptr, kNoDriver, credentials, false);
   SimulateMatchingPhase(&manager7, RESULT_NO_MATCH);
   EXPECT_FALSE(manager7.HasValidPasswordForm());
 }
 
 TEST_F(PasswordFormManagerTest, TestValidFormsBasic) {
   // User submits credentials for the observed form.
   PasswordForm credentials = *observed_form();
   credentials.scheme = PasswordForm::SCHEME_BASIC;
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = saved_match()->password_value;
 
   // Form with both username_element and password_element.
-  PasswordFormManager manager1(NULL, NULL, kNoDriver, credentials, false);
+  PasswordFormManager manager1(nullptr, nullptr, kNoDriver, credentials, false);
   SimulateMatchingPhase(&manager1, RESULT_NO_MATCH);
   EXPECT_TRUE(manager1.HasValidPasswordForm());
 
   // Form without a username_element but with a password_element.
   credentials.username_element.clear();
-  PasswordFormManager manager2(NULL, NULL, kNoDriver, credentials, false);
+  PasswordFormManager manager2(nullptr, nullptr, kNoDriver, credentials, false);
   SimulateMatchingPhase(&manager2, RESULT_NO_MATCH);
   EXPECT_TRUE(manager2.HasValidPasswordForm());
 
   // Form without a password_element but with a username_element.
   credentials.username_element = saved_match()->username_element;
   credentials.password_element.clear();
-  PasswordFormManager manager3(NULL, NULL, kNoDriver, credentials, false);
+  PasswordFormManager manager3(nullptr, nullptr, kNoDriver, credentials, false);
   SimulateMatchingPhase(&manager3, RESULT_NO_MATCH);
   EXPECT_TRUE(manager3.HasValidPasswordForm());
 
   // Form with neither a password_element nor a username_element.
   credentials.username_element.clear();
   credentials.password_element.clear();
-  PasswordFormManager manager4(NULL, NULL, kNoDriver, credentials, false);
+  PasswordFormManager manager4(nullptr, nullptr, kNoDriver, credentials, false);
   SimulateMatchingPhase(&manager4, RESULT_NO_MATCH);
   EXPECT_TRUE(manager4.HasValidPasswordForm());
 }
 
 TEST_F(PasswordFormManagerTest, TestSendNotBlacklistedMessage) {
   TestPasswordManager password_manager(client());
   PasswordFormManager manager_no_creds(
       &password_manager, client(), client()->driver(), *observed_form(), false);
 
   // First time sign-up attempt. Password store does not contain matching
@@ skipping 78 matching lines @@
   simulated_results[1]->username_value = ASCIIToUTF16("other@gmail.com");
   simulated_results[1]->password_element = ASCIIToUTF16("signup_password");
   simulated_results[1]->username_element = ASCIIToUTF16("signup_username");
   simulated_results[1]->type = PasswordForm::TYPE_GENERATED;
   SimulateFetchMatchingLoginsFromPasswordStore(&manager_no_match);
   manager_no_match.OnGetPasswordStoreResults(simulated_results.Pass());
   EXPECT_EQ(2u, password_manager.GetLatestBestMatches().size());
 }
 
 TEST_F(PasswordFormManagerTest, TestSanitizePossibleUsernames) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *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");
 
   SanitizePossibleUsernames(&manager, &credentials);
@@ skipping 108 matching lines @@
       GURL("http://accounts.google.com/a/ServiceLogin2");
   SimulateFetchMatchingLoginsFromPasswordStore(&manager);
   manager.OnGetPasswordStoreResults(simulated_results.Pass());
   EXPECT_EQ(1u, password_manager.GetLatestBestMatches().size());
   EXPECT_EQ("", password_manager.GetLatestBestMatches()
                     .begin()
                     ->second->original_signon_realm);
 }
 
 TEST_F(PasswordFormManagerTest, InvalidActionURLsDoNotMatch) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   PasswordForm invalid_action_form(*observed_form());
   invalid_action_form.action = GURL("http://");
   ASSERT_FALSE(invalid_action_form.action.is_valid());
   ASSERT_FALSE(invalid_action_form.action.is_empty());
   // Non-empty invalid action URLs should not match other actions.
   // First when the compared form has an invalid URL:
   EXPECT_EQ(0,
             manager.DoesManage(invalid_action_form) &
                 PasswordFormManager::RESULT_ACTION_MATCH);
   // Then when the observed form has an invalid URL:
   PasswordForm valid_action_form(*observed_form());
-  PasswordFormManager invalid_manager(NULL, client(), kNoDriver,
+  PasswordFormManager invalid_manager(nullptr, client(), kNoDriver,
                                       invalid_action_form, false);
   EXPECT_EQ(0,
             invalid_manager.DoesManage(valid_action_form) &
                 PasswordFormManager::RESULT_ACTION_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, EmptyActionURLsDoNotMatchNonEmpty) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   PasswordForm empty_action_form(*observed_form());
   empty_action_form.action = GURL();
   ASSERT_FALSE(empty_action_form.action.is_valid());
   ASSERT_TRUE(empty_action_form.action.is_empty());
   // First when the compared form has an empty URL:
   EXPECT_EQ(0,
             manager.DoesManage(empty_action_form) &
                 PasswordFormManager::RESULT_ACTION_MATCH);
   // Then when the observed form has an empty URL:
   PasswordForm valid_action_form(*observed_form());
-  PasswordFormManager empty_action_manager(NULL, client(), kNoDriver,
+  PasswordFormManager empty_action_manager(nullptr, client(), kNoDriver,
                                            empty_action_form, false);
   EXPECT_EQ(0,
             empty_action_manager.DoesManage(valid_action_form) &
                 PasswordFormManager::RESULT_ACTION_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, NonHTMLFormsDoNotMatchHTMLForms) {
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   ASSERT_EQ(PasswordForm::SCHEME_HTML, observed_form()->scheme);
   PasswordForm non_html_form(*observed_form());
   non_html_form.scheme = PasswordForm::SCHEME_DIGEST;
   EXPECT_EQ(0,
             manager.DoesManage(non_html_form) &
                 PasswordFormManager::RESULT_MANDATORY_ATTRIBUTES_MATCH);
 
   // The other way round: observing a non-HTML form, don't match a HTML form.
   PasswordForm html_form(*observed_form());
-  PasswordFormManager non_html_manager(NULL, client(), kNoDriver, non_html_form,
-                                       false);
+  PasswordFormManager non_html_manager(nullptr, client(), kNoDriver,
+                                       non_html_form, false);
   EXPECT_EQ(0,
             non_html_manager.DoesManage(html_form) &
                 PasswordFormManager::RESULT_MANDATORY_ATTRIBUTES_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, OriginCheck_HostsMatchExactly) {
   // Host part of origins must match exactly, not just by prefix.
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   PasswordForm form_longer_host(*observed_form());
   form_longer_host.origin = GURL("http://accounts.google.com.au/a/LoginAuth");
   // Check that accounts.google.com does not match accounts.google.com.au.
   EXPECT_EQ(0,
             manager.DoesManage(form_longer_host) &
                 PasswordFormManager::RESULT_MANDATORY_ATTRIBUTES_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, OriginCheck_MoreSecureSchemePathsMatchPrefix) {
   // If the URL scheme of the observed form is HTTP, and the compared form is
   // HTTPS, then the compared form can extend the path.
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   PasswordForm form_longer_path(*observed_form());
   form_longer_path.origin = GURL("https://accounts.google.com/a/LoginAuth/sec");
   EXPECT_NE(0,
             manager.DoesManage(form_longer_path) &
                 PasswordFormManager::RESULT_MANDATORY_ATTRIBUTES_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest,
        OriginCheck_NotMoreSecureSchemePathsMatchExactly) {
   // If the origin URL scheme of the compared form is not more secure than that
   // of the observed form, then the paths must match exactly.
-  PasswordFormManager manager(NULL, client(), kNoDriver, *observed_form(),
+  PasswordFormManager manager(nullptr, client(), kNoDriver, *observed_form(),
                               false);
 
   PasswordForm form_longer_path(*observed_form());
   form_longer_path.origin = GURL("http://accounts.google.com/a/LoginAuth/sec");
   // Check that /a/LoginAuth does not match /a/LoginAuth/more.
   EXPECT_EQ(0,
             manager.DoesManage(form_longer_path) &
                 PasswordFormManager::RESULT_MANDATORY_ATTRIBUTES_MATCH);
 
   PasswordForm secure_observed_form(*observed_form());
   secure_observed_form.origin = GURL("https://accounts.google.com/a/LoginAuth");
-  PasswordFormManager secure_manager(NULL, client(), kNoDriver,
+  PasswordFormManager secure_manager(nullptr, client(), kNoDriver,
                                      secure_observed_form, true);
   // Also for HTTPS in the observed form, and HTTP in the compared form, an
   // exact path match is expected.
   EXPECT_EQ(0,
             secure_manager.DoesManage(form_longer_path) &
                 PasswordFormManager::RESULT_MANDATORY_ATTRIBUTES_MATCH);
   // Not even upgrade to HTTPS in the compared form should help.
   form_longer_path.origin = GURL("https://accounts.google.com/a/LoginAuth/sec");
   EXPECT_EQ(0,
             secure_manager.DoesManage(form_longer_path) &
@@ skipping 305 matching lines @@
   // The user submits a password on a change-password form, which does not use
   // the "autocomplete=username" mark-up (therefore Chrome had to guess what is
   // the username), and the user-typed username does not match anything already
   // stored. There is not much confidence in the guess being right, so the
   // password should not be stored.
   EXPECT_TRUE(manager.IsIgnorableChangePasswordForm(
       ASCIIToUTF16("DifferentUsername"), saved_match()->password_value));
 }
 
 }  // namespace password_manager