Revert of [Password Manager] Convert |pending_login_managers_| to an array of scoped_refptr

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 "components/password_manager/core/browser/password_form_manager.h"
 
 #include <map>
 #include <memory>
 #include <set>
 #include <utility>
@@ skipping 369 matching lines @@
     field.name = ASCIIToUTF16("Email");
     field.form_control_type = "text";
     saved_match_.form_data.fields.push_back(field);
 
     field.label = ASCIIToUTF16("password");
     field.name = ASCIIToUTF16("Passwd");
     field.form_control_type = "password";
     saved_match_.form_data.fields.push_back(field);
 
     password_manager_.reset(new PasswordManager(&client_));
-    form_manager_ = base::MakeRefCounted<PasswordFormManager>(
+    form_manager_.reset(new PasswordFormManager(
         password_manager_.get(), &client_, client_.driver(), observed_form_,
-        base::MakeUnique<NiceMock<MockFormSaver>>(), &fake_form_fetcher_);
+        base::MakeUnique<NiceMock<MockFormSaver>>(), &fake_form_fetcher_));
   }
 
   // Save saved_match() for observed_form() where |observed_form_data|,
   // |times_used|, and |status| are used to overwrite the default values for
   // observed_form(). |field_type| is the upload that we expect from saving,
   // with nullptr meaning no upload expected.
   void AccountCreationUploadTest(const autofill::FormData& observed_form_data,
                                  int times_used,
                                  PasswordForm::GenerationUploadStatus status,
                                  const autofill::ServerFieldType* field_type) {
     PasswordForm form(*observed_form());
 
     form.form_data = observed_form_data;
 
     FakeFormFetcher fetcher;
     fetcher.Fetch();
-    scoped_refptr<PasswordFormManager> form_manager(
-        base::MakeRefCounted<PasswordFormManager>(
-            password_manager(), client(), client()->driver(), form,
-            base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+    PasswordFormManager form_manager(
+        password_manager(), client(), client()->driver(), form,
+        base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
     PasswordForm match = CreateSavedMatch(false);
     match.generation_upload_status = status;
     match.times_used = times_used;
 
     PasswordForm form_to_save(form);
     form_to_save.preferred = true;
     form_to_save.username_element = ASCIIToUTF16("observed-username-field");
     form_to_save.username_value = match.username_value;
     form_to_save.password_value = match.password_value;
 
     fetcher.SetNonFederated({&match}, 0u);
     std::string expected_login_signature;
     autofill::FormStructure observed_structure(observed_form_data);
     autofill::FormStructure pending_structure(saved_match()->form_data);
     if (observed_structure.FormSignatureAsStr() !=
             pending_structure.FormSignatureAsStr() &&
         times_used == 0) {
       expected_login_signature = observed_structure.FormSignatureAsStr();
     }
     autofill::ServerFieldTypeSet expected_available_field_types;
     FieldTypeMap expected_types;
     expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE;
     expected_types[match.username_element] = autofill::UNKNOWN_TYPE;
 
     bool expect_generation_vote = false;
     if (field_type) {
       // Show the password generation popup to check that the generation vote
       // would be ignored.
-      form_manager->set_generation_element(saved_match()->password_element);
-      form_manager->set_generation_popup_was_shown(true);
+      form_manager.set_generation_element(saved_match()->password_element);
+      form_manager.set_generation_popup_was_shown(true);
       expect_generation_vote =
           *field_type != autofill::ACCOUNT_CREATION_PASSWORD;
 
       expected_available_field_types.insert(*field_type);
       expected_types[saved_match()->password_element] = *field_type;
     }
 
     if (field_type) {
       EXPECT_CALL(
           *client()->mock_driver()->mock_autofill_download_manager(),
           StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
                                  pending_structure.FormSignatureAsStr(),
                                  expected_types, expect_generation_vote),
                              false, expected_available_field_types,
                              expected_login_signature, true));
     } else {
       EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
                   StartUploadRequest(_, _, _, _, _))
           .Times(0);
     }
-    form_manager->ProvisionallySave(
+    form_manager.ProvisionallySave(
         form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-    form_manager->Save();
+    form_manager.Save();
     Mock::VerifyAndClearExpectations(
         client()->mock_driver()->mock_autofill_download_manager());
   }
 
   // Test upload votes on change password forms. |field_type| is a vote that we
   // expect to be uploaded.
   void ChangePasswordUploadTest(autofill::ServerFieldType field_type,
                                 bool has_confirmation_field) {
     SCOPED_TRACE(testing::Message()
                  << "field_type=" << field_type
@@ skipping 13 matching lines @@
     observed_form()->form_data.fields.push_back(empty_field);
     if (has_confirmation_field) {
       field.label = ASCIIToUTF16("ConfPwd");
       field.name = ASCIIToUTF16("ConfPwd");
       field.form_control_type = "password";
       observed_form()->form_data.fields.push_back(field);
     }
 
     FakeFormFetcher fetcher;
     fetcher.Fetch();
-    scoped_refptr<PasswordFormManager> form_manager(
-        base::MakeRefCounted<PasswordFormManager>(
-            password_manager(), client(), client()->driver(), *observed_form(),
-            base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+    PasswordFormManager form_manager(
+        password_manager(), client(), client()->driver(), *observed_form(),
+        base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
     fetcher.SetNonFederated({saved_match()}, 0u);
 
     // User submits current and new credentials to the observed form.
     PasswordForm submitted_form(*observed_form());
     // credentials.username_element.clear();
     submitted_form.username_value = saved_match()->username_value;
     submitted_form.password_value = saved_match()->password_value;
     submitted_form.new_password_value = ASCIIToUTF16("test2");
     submitted_form.preferred = true;
-    form_manager->ProvisionallySave(
+    form_manager.ProvisionallySave(
         submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
     // Successful login. The PasswordManager would instruct PasswordFormManager
     // to update.
-    EXPECT_FALSE(form_manager->IsNewLogin());
+    EXPECT_FALSE(form_manager.IsNewLogin());
     EXPECT_FALSE(
-        form_manager->is_possible_change_password_form_without_username());
+        form_manager.is_possible_change_password_form_without_username());
 
     // By now, the PasswordFormManager should have promoted the new password
     // value already to be the current password, and should no longer maintain
     // any info about the new password value.
     EXPECT_EQ(submitted_form.new_password_value,
-              form_manager->pending_credentials().password_value);
-    EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty());
+              form_manager.pending_credentials().password_value);
+    EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty());
 
     std::map<base::string16, autofill::ServerFieldType> expected_types;
     expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE;
     expected_types[observed_form_.username_element] = autofill::UNKNOWN_TYPE;
     expected_types[observed_form_.password_element] = autofill::PASSWORD;
     expected_types[observed_form_.new_password_element] = field_type;
     expected_types[base::string16()] = autofill::UNKNOWN_TYPE;
 
     autofill::ServerFieldTypeSet expected_available_field_types;
     expected_available_field_types.insert(autofill::PASSWORD);
@@ skipping 15 matching lines @@
     }
     EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
                 StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
                                        observed_form_signature, expected_types,
                                        false /* expect_generation_vote */),
                                    false, expected_available_field_types,
                                    expected_login_signature, true));
 
     switch (field_type) {
       case autofill::NEW_PASSWORD:
-        form_manager->Update(*saved_match());
+        form_manager.Update(*saved_match());
         break;
       case autofill::PROBABLY_NEW_PASSWORD:
-        form_manager->OnNoInteraction(true /* it is an update */);
+        form_manager.OnNoInteraction(true /* it is an update */);
         break;
       case autofill::NOT_NEW_PASSWORD:
-        form_manager->OnNopeUpdateClicked();
+        form_manager.OnNopeUpdateClicked();
         break;
       default:
         NOTREACHED();
     }
     Mock::VerifyAndClearExpectations(
         client()->mock_driver()->mock_autofill_download_manager());
   }
 
   autofill::AutofillUploadContents::Field::PasswordGenerationType
   GetExpectedPasswordGenerationType(bool is_manual_generation,
@@ skipping 54 matching lines @@
     submitted_form.username_value = saved_match()->username_value;
     submitted_form.password_value = saved_match()->password_value;
 
     if (is_change_password_form) {
       submitted_form.new_password_value =
           saved_match()->password_value + ASCIIToUTF16("1");
     }
 
     FakeFormFetcher fetcher;
     fetcher.Fetch();
-    scoped_refptr<PasswordFormManager> form_manager(
-        base::MakeRefCounted<PasswordFormManager>(
-            password_manager(), client(), client()->driver(), form,
-            base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+    PasswordFormManager form_manager(
+        password_manager(), client(), client()->driver(), form,
+        base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
 
     fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
     autofill::ServerFieldTypeSet expected_available_field_types;
     // Don't send autofill votes if the user didn't press "Save" button.
     if (interaction == SAVE)
       expected_available_field_types.insert(autofill::PASSWORD);
 
-    form_manager->set_is_manual_generation(is_manual_generation);
+    form_manager.set_is_manual_generation(is_manual_generation);
     base::string16 generation_element = is_change_password_form
                                             ? form.new_password_element
                                             : form.password_element;
-    form_manager->set_generation_element(generation_element);
-    form_manager->set_generation_popup_was_shown(true);
-    form_manager->set_has_generated_password(has_generated_password);
+    form_manager.set_generation_element(generation_element);
+    form_manager.set_generation_popup_was_shown(true);
+    form_manager.set_has_generated_password(has_generated_password);
 
     // Figure out expected generation event type.
     autofill::AutofillUploadContents::Field::PasswordGenerationType
         expected_generation_type = GetExpectedPasswordGenerationType(
             is_manual_generation, is_change_password_form,
             has_generated_password);
     std::map<base::string16,
              autofill::AutofillUploadContents::Field::PasswordGenerationType>
         expected_generation_types;
     expected_generation_types[generation_element] = expected_generation_type;
 
     autofill::FormStructure form_structure(submitted_form.form_data);
 
     EXPECT_CALL(
         *client()->mock_driver()->mock_autofill_download_manager(),
         StartUploadRequest(
             CheckUploadedGenerationTypesAndSignature(
                 form_structure.FormSignatureAsStr(), expected_generation_types),
             false, expected_available_field_types, std::string(), true));
 
-    form_manager->ProvisionallySave(
+    form_manager.ProvisionallySave(
         submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
     switch (interaction) {
       case SAVE:
-        form_manager->Save();
+        form_manager.Save();
         break;
       case NEVER:
-        form_manager->OnNeverClicked();
+        form_manager.OnNeverClicked();
         break;
       case NO_INTERACTION:
-        form_manager->OnNoInteraction(false /* not an update prompt*/);
+        form_manager.OnNoInteraction(false /* not an update prompt*/);
         break;
     }
     Mock::VerifyAndClearExpectations(
         client()->mock_driver()->mock_autofill_download_manager());
   }
 
   PasswordForm* observed_form() { return &observed_form_; }
   PasswordForm* saved_match() { return &saved_match_; }
   PasswordForm* psl_saved_match() { return &psl_saved_match_; }
   PasswordForm CreateSavedMatch(bool blacklisted) {
@@ skipping 43 matching lines @@
     return form;
   }
 
   void SimulateActionsOnHTTPObservedForm(
       FakeFormFetcher* fetcher,
       SimulatedManagerAction manager_action,
       SimulatedSubmitResult submit_result,
       const char* filled_username,
       const char* filled_password,
       const char* submitted_password = nullptr) {
-    scoped_refptr<PasswordFormManager> form_manager(
-        base::MakeRefCounted<PasswordFormManager>(
-            password_manager(), client(), client()->driver(), *observed_form(),
-            base::MakeUnique<NiceMock<MockFormSaver>>(), fetcher));
+    PasswordFormManager form_manager(
+        password_manager(), client(), client()->driver(), *observed_form(),
+        base::MakeUnique<NiceMock<MockFormSaver>>(), fetcher);
 
     EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
                 StartUploadRequest(_, _, _, _, _))
         .Times(::testing::AnyNumber());
 
     PasswordForm http_stored_form = *saved_match();
     http_stored_form.username_value = base::ASCIIToUTF16(filled_username);
     http_stored_form.password_value = base::ASCIIToUTF16(filled_password);
     if (manager_action == SimulatedManagerAction::OFFERED_PSL)
       http_stored_form.is_public_suffix_match = true;
@@ skipping 15 matching lines @@
     fetcher->SetNonFederated(matches, 0u);
 
     if (submit_result != SimulatedSubmitResult::NONE) {
       PasswordForm submitted_form(*observed_form());
       submitted_form.preferred = true;
       submitted_form.username_value = base::ASCIIToUTF16(filled_username);
       submitted_form.password_value =
           submitted_password ? base::ASCIIToUTF16(submitted_password)
                              : base::ASCIIToUTF16(filled_password);
 
-      form_manager->ProvisionallySave(
+      form_manager.ProvisionallySave(
           submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
       if (submit_result == SimulatedSubmitResult::PASSED) {
-        form_manager->LogSubmitPassed();
-        form_manager->Save();
+        form_manager.LogSubmitPassed();
+        form_manager.Save();
       } else {
-        form_manager->LogSubmitFailed();
+        form_manager.LogSubmitFailed();
       }
     }
   }
 
  private:
   // Necessary for callbacks, and for TestAutofillDriver.
   base::MessageLoop message_loop_;
 
   PasswordForm observed_form_;
   PasswordForm saved_match_;
   PasswordForm psl_saved_match_;
   TestPasswordManagerClient client_;
   std::unique_ptr<PasswordManager> password_manager_;
   // Define |fake_form_fetcher_| before |form_manager_|, because the former
   // needs to outlive the latter.
   FakeFormFetcher fake_form_fetcher_;
-  scoped_refptr<PasswordFormManager> form_manager_;
+  std::unique_ptr<PasswordFormManager> form_manager_;
 };
 
 class PasswordFormManagerFillOnAccountSelectTest
     : public PasswordFormManagerTest {
  public:
   PasswordFormManagerFillOnAccountSelectTest() {
     scoped_feature_list_.InitAndEnableFeature(features::kFillOnAccountSelect);
   }
 
   base::test::ScopedFeatureList scoped_feature_list_;
@@ skipping 98 matching lines @@
 }
 
 // Test that stored blacklisted forms are correctly evaluated for whether they
 // apply to the observed form.
 TEST_F(PasswordFormManagerTest, TestBlacklistMatching) {
   observed_form()->origin = GURL("http://accounts.google.com/a/LoginAuth");
   observed_form()->action = GURL("http://accounts.google.com/a/Login");
   observed_form()->signon_realm = "http://accounts.google.com";
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
 
   // Doesn't apply because it is just a PSL match of the observed form.
   PasswordForm blacklisted_psl = *observed_form();
   blacklisted_psl.signon_realm = "http://m.accounts.google.com";
   blacklisted_psl.is_public_suffix_match = true;
   blacklisted_psl.blacklisted_by_user = true;
 
   // Doesn't apply because of different origin.
   PasswordForm blacklisted_not_match = *observed_form();
   blacklisted_not_match.origin = GURL("http://google.com/a/LoginAuth");
@@ skipping 22 matching lines @@
 
   std::vector<const PasswordForm*> matches = {&blacklisted_psl,
                                               &blacklisted_not_match,
                                               &blacklisted_not_match2,
                                               &blacklisted_not_match3,
                                               &blacklisted_match,
                                               &blacklisted_match2,
                                               saved_match()};
   fetcher.SetNonFederated(matches, 0u);
 
-  EXPECT_TRUE(form_manager->IsBlacklisted());
-  EXPECT_THAT(form_manager->blacklisted_matches(),
+  EXPECT_TRUE(form_manager.IsBlacklisted());
+  EXPECT_THAT(form_manager.blacklisted_matches(),
               UnorderedElementsAre(Pointee(blacklisted_match),
                                    Pointee(blacklisted_match2)));
-  EXPECT_EQ(1u, form_manager->best_matches().size());
-  EXPECT_EQ(*saved_match(), *form_manager->preferred_match());
+  EXPECT_EQ(1u, form_manager.best_matches().size());
+  EXPECT_EQ(*saved_match(), *form_manager.preferred_match());
 }
 
 // Test that even in the presence of blacklisted matches, the non-blacklisted
 // ones are still autofilled.
 TEST_F(PasswordFormManagerTest, AutofillBlacklisted) {
   PasswordForm saved_form = *observed_form();
   saved_form.username_value = ASCIIToUTF16("user");
   saved_form.password_value = ASCIIToUTF16("pass");
 
   PasswordForm blacklisted = *observed_form();
@@ skipping 69 matching lines @@
 }
 
 // Test that when the submitted form contains a "new-password" field, then the
 // password value is taken from there.
 TEST_F(PasswordFormManagerTest, TestNewLoginFromNewPasswordElement) {
   observed_form()->new_password_element = ASCIIToUTF16("NewPasswd");
   observed_form()->username_marked_by_site = true;
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
   // User enters current and new credentials to the observed form.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = ASCIIToUTF16("oldpassword");
   credentials.new_password_value = ASCIIToUTF16("newpassword");
   credentials.preferred = true;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Successful login. The PasswordManager would instruct PasswordFormManager
   // to save, which should know this is a new login.
-  EXPECT_TRUE(form_manager->IsNewLogin());
-  EXPECT_EQ(credentials.origin, form_manager->pending_credentials().origin);
+  EXPECT_TRUE(form_manager.IsNewLogin());
+  EXPECT_EQ(credentials.origin, form_manager.pending_credentials().origin);
   EXPECT_EQ(credentials.signon_realm,
-            form_manager->pending_credentials().signon_realm);
-  EXPECT_EQ(credentials.action, form_manager->pending_credentials().action);
-  EXPECT_TRUE(form_manager->pending_credentials().preferred);
+            form_manager.pending_credentials().signon_realm);
+  EXPECT_EQ(credentials.action, form_manager.pending_credentials().action);
+  EXPECT_TRUE(form_manager.pending_credentials().preferred);
   EXPECT_EQ(credentials.username_value,
-            form_manager->pending_credentials().username_value);
+            form_manager.pending_credentials().username_value);
 
   // By this point, the PasswordFormManager should have promoted the new
   // password value to be the current password, and should have wiped the
   // password element name: it is likely going to be different on a login
   // form, so it is not worth remembering them.
   EXPECT_EQ(credentials.new_password_value,
-            form_manager->pending_credentials().password_value);
-  EXPECT_TRUE(form_manager->pending_credentials().password_element.empty());
-  EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty());
+            form_manager.pending_credentials().password_value);
+  EXPECT_TRUE(form_manager.pending_credentials().password_element.empty());
+  EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty());
 }
 
 TEST_F(PasswordFormManagerTest, TestUpdatePassword) {
   fake_form_fetcher()->SetNonFederated({saved_match()}, 0u);
 
   // 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.
@@ skipping 30 matching lines @@
   // 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| during updating as a special case. We will
   // verify in the end that this did not happen.
   saved_match()->submit_element.clear();
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   fetcher.SetNonFederated({saved_match()}, 0u);
 
   // 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;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Successful login. The PasswordManager would instruct PasswordFormManager
   // to save, and since this is an update, it should know not to save as a new
   // login.
-  EXPECT_FALSE(form_manager->IsNewLogin());
+  EXPECT_FALSE(form_manager.IsNewLogin());
 
   // By now, the PasswordFormManager should have promoted the new password value
   // already to be the current password, and should no longer maintain any info
   // about the new password.
   EXPECT_EQ(credentials.new_password_value,
-            form_manager->pending_credentials().password_value);
-  EXPECT_TRUE(form_manager->pending_credentials().new_password_element.empty());
-  EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty());
+            form_manager.pending_credentials().password_value);
+  EXPECT_TRUE(form_manager.pending_credentials().new_password_element.empty());
+  EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty());
 
   // Trigger saving to exercise some special case handling for updating.
   PasswordForm new_credentials;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr))
+  EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr))
       .WillOnce(testing::SaveArg<0>(&new_credentials));
 
-  form_manager->Save();
+  form_manager.Save();
 
   // 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 that saved results are not ignored if they differ in paths for action or
 // origin.
 TEST_F(PasswordFormManagerTest, TestIgnoreResult_Paths) {
   PasswordForm observed(*observed_form());
   observed.origin = GURL("https://accounts.google.com/a/LoginAuth");
   observed.action = GURL("https://accounts.google.com/a/Login");
   observed.signon_realm = "https://accounts.google.com";
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), observed,
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), observed,
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
 
   PasswordForm saved_form = observed;
   saved_form.origin = GURL("https://accounts.google.com/a/OtherLoginAuth");
   saved_form.action = GURL("https://accounts.google.com/a/OtherLogin");
   fetcher.SetNonFederated({&saved_form}, 0u);
 
   // Different paths for action / origin are okay.
-  EXPECT_EQ(1u, form_manager->best_matches().size());
-  EXPECT_EQ(*form_manager->best_matches().begin()->second, saved_form);
+  EXPECT_EQ(1u, form_manager.best_matches().size());
+  EXPECT_EQ(*form_manager.best_matches().begin()->second, saved_form);
 }
 
 // Test that saved empty action URL is updated with the submitted action URL.
 TEST_F(PasswordFormManagerTest, TestEmptyAction) {
   saved_match()->action = GURL();
   fake_form_fetcher()->SetNonFederated({saved_match()}, 0u);
 
   // User logs in with the autofilled username / password from saved_match.
   PasswordForm login = *observed_form();
   login.username_value = saved_match()->username_value;
@@ skipping 139 matching lines @@
 TEST_F(PasswordFormManagerTest,
        TestSendNotBlacklistedMessage_DroppedCredentials) {
   // There are cases, such as when a form is made explicitly for creating a new
   // password, where we may ignore saved credentials. Make sure that we still
   // allow generation in that case.
   PasswordForm signup_form(*observed_form());
   signup_form.new_password_element = base::ASCIIToUTF16("new_password_field");
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), signup_form,
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), signup_form,
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_));
   PasswordForm simulated_result = CreateSavedMatch(false);
   fetcher.SetNonFederated({&simulated_result}, 0u);
 }
 
 TEST_F(PasswordFormManagerTest,
        TestSendNotBlacklistedMessage_BlacklistedCredentials) {
   // Signing up on a previously visited site. Credentials are found in the
   // password store, but they are blacklisted. AllowPasswordGenerationForForm
   // is still called.
@@ skipping 129 matching lines @@
   encountered_form.signon_realm = "http://accounts.google.com/";
   encountered_form.action = GURL("http://accounts.google.com/Login");
   encountered_form.username_element = ASCIIToUTF16("Email");
   encountered_form.password_element = ASCIIToUTF16("Passwd");
   encountered_form.submit_element = ASCIIToUTF16("signIn");
 
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_));
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), encountered_form,
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), encountered_form,
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
 
   PasswordForm incomplete_form;
   incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth");
   incomplete_form.signon_realm = "http://accounts.google.com/";
   incomplete_form.password_value = ASCIIToUTF16("my_password");
   incomplete_form.username_value = ASCIIToUTF16("my_username");
   incomplete_form.preferred = true;
   incomplete_form.scheme = PasswordForm::SCHEME_HTML;
 
   // We expect to see this form eventually sent to the Password store. It
   // has password/username values from the store and 'username_element',
   // 'password_element', 'submit_element' and 'action' fields copied from
   // the encountered form.
   PasswordForm complete_form(incomplete_form);
   complete_form.action = encountered_form.action;
   complete_form.password_element = encountered_form.password_element;
   complete_form.username_element = encountered_form.username_element;
   complete_form.submit_element = encountered_form.submit_element;
 
   PasswordForm obsolete_form(incomplete_form);
   obsolete_form.action = encountered_form.action;
 
   // Feed the incomplete credentials to the manager.
   fetcher.SetNonFederated({&incomplete_form}, 0u);
 
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       complete_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
   // By now that form has been used once.
   complete_form.times_used = 1;
   obsolete_form.times_used = 1;
 
   // Check that PasswordStore receives an update request with the complete form.
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()),
+  EXPECT_CALL(MockFormSaver::Get(&form_manager),
               Update(complete_form, _, _, Pointee(obsolete_form)));
-  form_manager->Save();
+  form_manager.Save();
 }
 
 // Test that public-suffix-matched credentials score lower than same-origin
 // ones.
 TEST_F(PasswordFormManagerTest, TestScoringPublicSuffixMatch) {
   EXPECT_CALL(*(client()->mock_driver()), AllowPasswordGenerationForForm(_));
 
   PasswordForm base_match = CreateSavedMatch(false);
   base_match.origin = GURL("http://accounts.google.com/a/ServiceLoginAuth");
   base_match.action = GURL("http://accounts.google.com/a/ServiceLogin");
@@ skipping 121 matching lines @@
   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, form_manager()->DoesManage(invalid_action_form, nullptr) &
                    PasswordFormManager::RESULT_ACTION_MATCH);
   // Then when the observed form has an invalid URL:
   PasswordForm valid_action_form(*observed_form());
-  scoped_refptr<PasswordFormManager> invalid_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), invalid_action_form,
-          base::MakeUnique<MockFormSaver>(), fake_form_fetcher()));
-  EXPECT_EQ(0, invalid_manager->DoesManage(valid_action_form, nullptr) &
+  PasswordFormManager invalid_manager(
+      password_manager(), client(), client()->driver(), invalid_action_form,
+      base::MakeUnique<MockFormSaver>(), fake_form_fetcher());
+  EXPECT_EQ(0, invalid_manager.DoesManage(valid_action_form, nullptr) &
                    PasswordFormManager::RESULT_ACTION_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, EmptyActionURLsDoNotMatchNonEmpty) {
   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, form_manager()->DoesManage(empty_action_form, nullptr) &
                    PasswordFormManager::RESULT_ACTION_MATCH);
   // Then when the observed form has an empty URL:
   PasswordForm valid_action_form(*observed_form());
-  scoped_refptr<PasswordFormManager> empty_action_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), empty_action_form,
-          base::MakeUnique<MockFormSaver>(), fake_form_fetcher()));
-  EXPECT_EQ(0, empty_action_manager->DoesManage(valid_action_form, nullptr) &
+  PasswordFormManager empty_action_manager(
+      password_manager(), client(), client()->driver(), empty_action_form,
+      base::MakeUnique<MockFormSaver>(), fake_form_fetcher());
+  EXPECT_EQ(0, empty_action_manager.DoesManage(valid_action_form, nullptr) &
                    PasswordFormManager::RESULT_ACTION_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, NonHTMLFormsDoNotMatchHTMLForms) {
   ASSERT_EQ(PasswordForm::SCHEME_HTML, observed_form()->scheme);
   PasswordForm non_html_form(*observed_form());
   non_html_form.scheme = PasswordForm::SCHEME_DIGEST;
   EXPECT_EQ(0, form_manager()->DoesManage(non_html_form, nullptr) &
                    PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH);
 
   // The other way round: observing a non-HTML form, don't match a HTML form.
   PasswordForm html_form(*observed_form());
-  scoped_refptr<PasswordFormManager> non_html_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), kNoDriver, non_html_form,
-          base::MakeUnique<MockFormSaver>(), fake_form_fetcher()));
-  EXPECT_EQ(0, non_html_manager->DoesManage(html_form, nullptr) &
+  PasswordFormManager non_html_manager(
+      password_manager(), client(), kNoDriver, non_html_form,
+      base::MakeUnique<MockFormSaver>(), fake_form_fetcher());
+  EXPECT_EQ(0, non_html_manager.DoesManage(html_form, nullptr) &
                    PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, OriginCheck_HostsMatchExactly) {
   // Host part of origins must match exactly, not just by prefix.
   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, form_manager()->DoesManage(form_longer_host, nullptr) &
                    PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH);
@@ skipping 13 matching lines @@
   // 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.
   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, form_manager()->DoesManage(form_longer_path, nullptr) &
                    PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH);
 
   PasswordForm secure_observed_form(*observed_form());
   secure_observed_form.origin = GURL("https://accounts.google.com/a/LoginAuth");
-  scoped_refptr<PasswordFormManager> secure_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(),
-          secure_observed_form, base::MakeUnique<MockFormSaver>(),
-          fake_form_fetcher()));
+  PasswordFormManager secure_manager(
+      password_manager(), client(), client()->driver(), secure_observed_form,
+      base::MakeUnique<MockFormSaver>(), fake_form_fetcher());
   // 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, nullptr) &
+  EXPECT_EQ(0, secure_manager.DoesManage(form_longer_path, nullptr) &
                    PasswordFormManager::RESULT_HTML_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, nullptr) &
+  EXPECT_EQ(0, secure_manager.DoesManage(form_longer_path, nullptr) &
                    PasswordFormManager::RESULT_HTML_ATTRIBUTES_MATCH);
 }
 
 TEST_F(PasswordFormManagerTest, OriginCheck_OnlyOriginsMatch) {
   // Make sure DoesManage() can distinguish when only origins match.
 
   PasswordForm different_html_attributes(*observed_form());
   different_html_attributes.password_element = ASCIIToUTF16("random_pass");
   different_html_attributes.username_element = ASCIIToUTF16("random_user");
 
@@ skipping 67 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("third"), credentials_to_update[0].password_value);
   EXPECT_FALSE(credentials_to_update[0].password_element.empty());
   EXPECT_TRUE(credentials_to_update[0].username_element.empty());
 }
 
 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword) {
   // For newly saved passwords, upload a password vote for autofill::PASSWORD.
   // Don't vote for the username field yet.
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *saved_match(),
-          base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+  PasswordFormManager form_manager(
+      password_manager(), client(), client()->driver(), *saved_match(),
+      base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
   fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
   PasswordForm form_to_save(*saved_match());
   form_to_save.preferred = true;
   form_to_save.username_value = ASCIIToUTF16("username");
   form_to_save.password_value = ASCIIToUTF16("1234");
 
   autofill::ServerFieldTypeSet expected_available_field_types;
   expected_available_field_types.insert(autofill::PASSWORD);
   EXPECT_CALL(
       *client()->mock_driver()->mock_autofill_download_manager(),
       StartUploadRequest(_, false, expected_available_field_types, _, true));
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  form_manager->Save();
+  form_manager.Save();
 }
 
 TEST_F(PasswordFormManagerTest, UploadFormData_NewPassword_Blacklist) {
   // Do not upload a vote if the user is blacklisting the form.
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> blacklist_form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *saved_match(),
-          base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+  PasswordFormManager blacklist_form_manager(
+      password_manager(), client(), client()->driver(), *saved_match(),
+      base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
   fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
   autofill::ServerFieldTypeSet expected_available_field_types;
   expected_available_field_types.insert(autofill::USERNAME);
   expected_available_field_types.insert(autofill::PASSWORD);
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(_, _, expected_available_field_types, _, true))
       .Times(0);
-  blacklist_form_manager->PermanentlyBlacklist();
+  blacklist_form_manager.PermanentlyBlacklist();
 }
 
 TEST_F(PasswordFormManagerTest, UploadPasswordForm) {
   autofill::FormData observed_form_data;
   autofill::FormFieldData field;
   field.label = ASCIIToUTF16("Email");
   field.name = ASCIIToUTF16("observed-username-field");
   field.form_control_type = "text";
   observed_form_data.fields.push_back(field);
 
@@ skipping 64 matching lines @@
   PasswordForm form;
   form.origin = GURL(example_url);
   form.signon_realm = example_url;
   form.action = GURL(example_url);
   form.username_element = ASCIIToUTF16("u");
   form.password_element = ASCIIToUTF16("p");
   form.submit_element = ASCIIToUTF16("s");
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), form,
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), form,
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
 
   // Suddenly, the frame and its driver disappear.
   client()->KillDriver();
 
   fetcher.SetNonFederated({&form}, 0u);
 }
 
 TEST_F(PasswordFormManagerTest, PreferredMatchIsUpToDate) {
   // Check that preferred_match() is always a member of best_matches().
   PasswordForm form = *observed_form();
@@ skipping 57 matching lines @@
 }
 
 TEST_F(PasswordFormManagerTest, TestSuggestingPasswordChangeForms) {
   // Suggesting password on the password change form on the previously visited
   // site. Credentials are found in the password store, and are not blacklisted.
   PasswordForm observed_change_password_form = *observed_form();
   observed_change_password_form.new_password_element =
       base::ASCIIToUTF16("new_pwd");
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> manager_creds(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(),
-          observed_change_password_form, base::MakeUnique<MockFormSaver>(),
-          &fetcher));
+  PasswordFormManager manager_creds(
+      password_manager(), client(), client()->driver(),
+      observed_change_password_form, base::MakeUnique<MockFormSaver>(),
+      &fetcher);
 
   autofill::PasswordFormFillData fill_data;
   EXPECT_CALL(*client()->mock_driver(), FillPasswordForm(_))
       .WillOnce(SaveArg<0>(&fill_data));
 
   PasswordForm result = CreateSavedMatch(false);
   fetcher.SetNonFederated({&result}, 0u);
-  EXPECT_EQ(1u, manager_creds->best_matches().size());
+  EXPECT_EQ(1u, manager_creds.best_matches().size());
   EXPECT_EQ(0u, fill_data.additional_logins.size());
   EXPECT_TRUE(fill_data.wait_for_username);
 }
 
 TEST_F(PasswordFormManagerTest, TestUpdateMethod) {
   // 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");
   autofill::FormFieldData field;
   field.label = ASCIIToUTF16("NewPasswd");
   field.name = ASCIIToUTF16("NewPasswd");
   field.form_control_type = "password";
   observed_form()->form_data.fields.push_back(field);
 
   // 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| during updating as a special case. We will
   // verify in the end that this did not happen.
   saved_match()->submit_element.clear();
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
 
   fetcher.SetNonFederated({saved_match()}, 0u);
 
   // User submits current and new credentials to the observed form.
   PasswordForm credentials(*observed_form());
   credentials.username_element.clear();
   credentials.password_value = saved_match()->password_value;
   credentials.new_password_value = ASCIIToUTF16("test2");
   credentials.preferred = true;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Successful login. The PasswordManager would instruct PasswordFormManager
   // to save, and since this is an update, it should know not to save as a new
   // login.
-  EXPECT_FALSE(form_manager->IsNewLogin());
+  EXPECT_FALSE(form_manager.IsNewLogin());
   EXPECT_FALSE(
-      form_manager->is_possible_change_password_form_without_username());
+      form_manager.is_possible_change_password_form_without_username());
 
   // By now, the PasswordFormManager should have promoted the new password value
   // already to be the current password, and should no longer maintain any info
   // about the new password value.
   EXPECT_EQ(credentials.new_password_value,
-            form_manager->pending_credentials().password_value);
-  EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty());
+            form_manager.pending_credentials().password_value);
+  EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty());
 
   // Trigger saving to exercise some special case handling during updating.
   PasswordForm new_credentials;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr))
+  EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr))
       .WillOnce(SaveArg<0>(&new_credentials));
 
-  form_manager->Update(*saved_match());
+  form_manager.Update(*saved_match());
 
   // 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, TestUpdateNoUsernameTextfieldPresent) {
   // Add a new password field to the test form and insert a |username_value|
@@ skipping 10 matching lines @@
   // 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| during updating as a special case. We
   // will verify in the end that this did not happen.
   saved_match()->submit_element.clear();
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
 
   fetcher.SetNonFederated({saved_match()}, 0u);
 
   // User submits current and new credentials to the observed form.
   PasswordForm credentials(*observed_form());
   // The |username_value| contains a text that's unlikely to be real username.
   credentials.username_value = ASCIIToUTF16("3");
   credentials.password_value = saved_match()->password_value;
   credentials.new_password_value = ASCIIToUTF16("test2");
   credentials.preferred = true;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Successful login. The PasswordManager would instruct PasswordFormManager
   // to save, and since this is an update, it should know not to save as a new
   // login.
-  EXPECT_FALSE(form_manager->IsNewLogin());
-  EXPECT_TRUE(
-      form_manager->is_possible_change_password_form_without_username());
+  EXPECT_FALSE(form_manager.IsNewLogin());
+  EXPECT_TRUE(form_manager.is_possible_change_password_form_without_username());
 
   // By now, the PasswordFormManager should have promoted the new password value
   // already to be the current password, and should no longer maintain any info
   // about the new password value.
   EXPECT_EQ(saved_match()->username_value,
-            form_manager->pending_credentials().username_value);
+            form_manager.pending_credentials().username_value);
   EXPECT_EQ(credentials.new_password_value,
-            form_manager->pending_credentials().password_value);
-  EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty());
+            form_manager.pending_credentials().password_value);
+  EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty());
 
   // Trigger saving to exercise some special case handling during updating.
   PasswordForm new_credentials;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr))
+  EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr))
       .WillOnce(SaveArg<0>(&new_credentials));
 
-  form_manager->Update(form_manager->pending_credentials());
+  form_manager.Update(form_manager.pending_credentials());
 
   // No other information than password value should be updated. In particular
   // not the username.
   EXPECT_EQ(saved_match()->username_value, new_credentials.username_value);
   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 that if WipeStoreCopyIfOutdated is called before password store
 // callback, the UMA is signalled accordingly.
 TEST_F(PasswordFormManagerTest, WipeStoreCopyIfOutdated_BeforeStoreCallback) {
   PasswordForm form(*saved_match());
   form.password_value = ASCIIToUTF16("nonempty-password");
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), form,
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), form,
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   // The creation of |fetcher| keeps it waiting for store results. This test
   // keeps the fetcher waiting on purpose.
 
   PasswordForm submitted_form(form);
   submitted_form.password_value += ASCIIToUTF16("add stuff, make it different");
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   base::HistogramTester histogram_tester;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()),
-              WipeOutdatedCopies(form_manager->pending_credentials(), _, _));
-  form_manager->WipeStoreCopyIfOutdated();
+  EXPECT_CALL(MockFormSaver::Get(&form_manager),
+              WipeOutdatedCopies(form_manager.pending_credentials(), _, _));
+  form_manager.WipeStoreCopyIfOutdated();
   histogram_tester.ExpectUniqueSample("PasswordManager.StoreReadyWhenWiping", 0,
                                       1);
 }
 
 TEST_F(PasswordFormManagerTest, GenerationStatusChangedWithPassword) {
   PasswordForm generated_form = *observed_form();
   generated_form.type = PasswordForm::TYPE_GENERATED;
   generated_form.username_value = ASCIIToUTF16("username");
   generated_form.password_value = ASCIIToUTF16("password2");
   generated_form.preferred = true;
@@ skipping 98 matching lines @@
   bool kFalseTrue[] = {false, true};
   for (autofill::ServerFieldType vote : kChangePasswordVotes) {
     for (bool has_confirmation_field : kFalseTrue)
       ChangePasswordUploadTest(vote, has_confirmation_field);
   }
 }
 
 TEST_F(PasswordFormManagerTest, TestUpdatePSLMatchedCredentials) {
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u);
 
   // User submits a credentials with an old username and a new password.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = ASCIIToUTF16("new_password");
   credentials.preferred = true;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Successful login. The PasswordManager would instruct PasswordFormManager
   // to save, and since this is an update, it should know not to save as a new
   // login.
-  EXPECT_FALSE(form_manager->IsNewLogin());
+  EXPECT_FALSE(form_manager.IsNewLogin());
 
   // Trigger saving to exercise some special case handling during updating.
   PasswordForm new_credentials;
   std::vector<autofill::PasswordForm> credentials_to_update;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Update(_, _, _, nullptr))
+  EXPECT_CALL(MockFormSaver::Get(&form_manager), Update(_, _, _, nullptr))
       .WillOnce(testing::DoAll(SaveArg<0>(&new_credentials),
                                SaveArgPointee<2>(&credentials_to_update)));
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(_, false, _, _, true));
 
-  form_manager->Save();
+  form_manager.Save();
 
   // No meta-information should be updated, only the password.
   EXPECT_EQ(credentials.password_value, new_credentials.password_value);
   EXPECT_EQ(saved_match()->username_value, new_credentials.username_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()->origin, new_credentials.origin);
 
   ASSERT_EQ(1u, credentials_to_update.size());
   EXPECT_EQ(credentials.password_value,
             credentials_to_update[0].password_value);
   EXPECT_EQ(psl_saved_match()->username_element,
             credentials_to_update[0].username_element);
   EXPECT_EQ(psl_saved_match()->username_element,
             credentials_to_update[0].username_element);
   EXPECT_EQ(psl_saved_match()->password_element,
             credentials_to_update[0].password_element);
   EXPECT_EQ(psl_saved_match()->origin, credentials_to_update[0].origin);
 }
 
 TEST_F(PasswordFormManagerTest,
        TestNotUpdatePSLMatchedCredentialsWithAnotherUsername) {
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   psl_saved_match()->username_value += ASCIIToUTF16("1");
   fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u);
 
   // User submits a credentials with an old username and a new password.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = ASCIIToUTF16("new_password");
   credentials.preferred = true;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Successful login. The PasswordManager would instruct PasswordFormManager
   // to save, and since this is an update, it should know not to save as a new
   // login.
-  EXPECT_FALSE(form_manager->IsNewLogin());
+  EXPECT_FALSE(form_manager.IsNewLogin());
 
   // Trigger saving to exercise some special case handling during updating.
   PasswordForm new_credentials;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()),
+  EXPECT_CALL(MockFormSaver::Get(&form_manager),
               Update(_, _, Pointee(IsEmpty()), nullptr))
       .WillOnce(testing::SaveArg<0>(&new_credentials));
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(_, false, _, _, true));
 
-  form_manager->Save();
+  form_manager.Save();
 
   // No meta-information should be updated, only the password.
   EXPECT_EQ(credentials.password_value, new_credentials.password_value);
   EXPECT_EQ(saved_match()->username_value, new_credentials.username_value);
   EXPECT_EQ(saved_match()->password_element, new_credentials.password_element);
   EXPECT_EQ(saved_match()->username_element, new_credentials.username_element);
   EXPECT_EQ(saved_match()->origin, new_credentials.origin);
 }
 
 TEST_F(PasswordFormManagerTest,
        TestNotUpdatePSLMatchedCredentialsWithAnotherPassword) {
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   psl_saved_match()->password_value += ASCIIToUTF16("1");
   fetcher.SetNonFederated({saved_match(), psl_saved_match()}, 0u);
 
   // User submits a credentials with an old username and a new password.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = ASCIIToUTF16("new_password");
   credentials.preferred = true;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Successful login. The PasswordManager would instruct PasswordFormManager
   // to save, and since this is an update, it should know not to save as a new
   // login.
-  EXPECT_FALSE(form_manager->IsNewLogin());
+  EXPECT_FALSE(form_manager.IsNewLogin());
 
   // Trigger saving to exercise some special case handling during updating.
   PasswordForm new_credentials;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()),
+  EXPECT_CALL(MockFormSaver::Get(&form_manager),
               Update(_, _, Pointee(IsEmpty()), nullptr))
       .WillOnce(testing::SaveArg<0>(&new_credentials));
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(_, false, _, _, true));
 
-  form_manager->Save();
+  form_manager.Save();
 
   // No meta-information should be updated, only the password.
   EXPECT_EQ(credentials.password_value, new_credentials.password_value);
   EXPECT_EQ(saved_match()->username_value, new_credentials.username_value);
   EXPECT_EQ(saved_match()->password_element, new_credentials.password_element);
   EXPECT_EQ(saved_match()->username_element, new_credentials.username_element);
   EXPECT_EQ(saved_match()->origin, new_credentials.origin);
 }
 
 TEST_F(PasswordFormManagerTest, TestNotUpdateWhenOnlyPSLMatched) {
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   fetcher.SetNonFederated({psl_saved_match()}, 0u);
 
   // User submits a credentials with an old username and a new password.
   PasswordForm credentials(*observed_form());
   credentials.username_value = saved_match()->username_value;
   credentials.password_value = ASCIIToUTF16("new_password");
   credentials.preferred = true;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
-  EXPECT_TRUE(form_manager->IsNewLogin());
+  EXPECT_TRUE(form_manager.IsNewLogin());
 
   // PSL matched credential should not be updated, since we are not sure that
   // this is the same credential as submitted one.
   PasswordForm new_credentials;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Save(_, _, nullptr))
+  EXPECT_CALL(MockFormSaver::Get(&form_manager), Save(_, _, nullptr))
       .WillOnce(testing::SaveArg<0>(&new_credentials));
 
-  form_manager->Save();
+  form_manager.Save();
 
   EXPECT_EQ(credentials.password_value, new_credentials.password_value);
   EXPECT_EQ(credentials.username_value, new_credentials.username_value);
   EXPECT_EQ(credentials.password_element, new_credentials.password_element);
   EXPECT_EQ(credentials.username_element, new_credentials.username_element);
   EXPECT_EQ(credentials.origin, new_credentials.origin);
 }
 
 TEST_F(PasswordFormManagerTest,
        TestSavingOnChangePasswordFormGenerationNoStoredForms) {
@@ skipping 114 matching lines @@
   field.name = ASCIIToUTF16("Passwd");
   field.form_control_type = "password";
   observed_form()->form_data.fields.push_back(field);
 
   field.label = ASCIIToUTF16("new password");
   field.name = ASCIIToUTF16("NewPasswd");
   observed_form()->form_data.fields.push_back(field);
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   fetcher.SetNonFederated({saved_match()}, 0u);
 
   // User submits current and new credentials to the observed form.
   PasswordForm submitted_form(*observed_form());
   submitted_form.password_value = saved_match()->password_value;
   submitted_form.new_password_value = ASCIIToUTF16("test2");
   submitted_form.preferred = true;
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
   // Successful login. The PasswordManager would instruct PasswordFormManager
   // to update.
-  EXPECT_FALSE(form_manager->IsNewLogin());
-  EXPECT_TRUE(
-      form_manager->is_possible_change_password_form_without_username());
+  EXPECT_FALSE(form_manager.IsNewLogin());
+  EXPECT_TRUE(form_manager.is_possible_change_password_form_without_username());
 
   // By now, the PasswordFormManager should have promoted the new password
   // value already to be the current password, and should no longer maintain
   // any info about the new password value.
   EXPECT_EQ(submitted_form.new_password_value,
-            form_manager->pending_credentials().password_value);
-  EXPECT_TRUE(form_manager->pending_credentials().new_password_value.empty());
+            form_manager.pending_credentials().password_value);
+  EXPECT_TRUE(form_manager.pending_credentials().new_password_value.empty());
 
   std::map<base::string16, autofill::ServerFieldType> expected_types;
   expected_types[observed_form()->password_element] = autofill::PASSWORD;
   expected_types[observed_form()->new_password_element] =
       autofill::NEW_PASSWORD;
 
   autofill::ServerFieldTypeSet expected_available_field_types;
   expected_available_field_types.insert(autofill::PASSWORD);
   expected_available_field_types.insert(autofill::NEW_PASSWORD);
 
   std::string observed_form_signature =
       autofill::FormStructure(observed_form()->form_data).FormSignatureAsStr();
 
   std::string expected_login_signature =
       autofill::FormStructure(saved_match()->form_data).FormSignatureAsStr();
 
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(CheckUploadedAutofillTypesAndSignature(
                                      observed_form_signature, expected_types,
                                      false /* expect_generation_vote */),
                                  false, expected_available_field_types,
                                  expected_login_signature, true));
 
-  form_manager->Update(*saved_match());
+  form_manager.Update(*saved_match());
 }
 
 // Checks uploading a vote about the usage of the password generation popup.
 TEST_F(PasswordFormManagerTest, GeneratedVoteUpload) {
   bool kFalseTrue[] = {false, true};
   SavePromptInteraction kSavePromptInterations[] = {SAVE, NEVER,
                                                     NO_INTERACTION};
   for (bool is_manual_generation : kFalseTrue) {
     for (bool is_change_password_form : kFalseTrue) {
       for (bool has_generated_password : kFalseTrue) {
@@ skipping 15 matching lines @@
     form.form_data = saved_match()->form_data;
 
     // Create submitted form.
     PasswordForm submitted_form(form);
     submitted_form.preferred = true;
     submitted_form.username_value = saved_match()->username_value;
     submitted_form.password_value = saved_match()->password_value;
 
     FakeFormFetcher fetcher;
     fetcher.Fetch();
-    scoped_refptr<PasswordFormManager> form_manager(
-        base::MakeRefCounted<PasswordFormManager>(
-            password_manager(), client(), client()->driver(), form,
-            base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+    PasswordFormManager form_manager(
+        password_manager(), client(), client()->driver(), form,
+        base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
     base::string16 generation_element = form.password_element;
     if (found_generation_element)
-      form_manager->SaveGenerationFieldDetectedByClassifier(generation_element);
+      form_manager.SaveGenerationFieldDetectedByClassifier(generation_element);
     else
-      form_manager->SaveGenerationFieldDetectedByClassifier(base::string16());
+      form_manager.SaveGenerationFieldDetectedByClassifier(base::string16());
 
     fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
     autofill::FormStructure form_structure(submitted_form.form_data);
 
     EXPECT_CALL(
         *client()->mock_driver()->mock_autofill_download_manager(),
         StartUploadRequest(CheckUploadedFormClassifierVote(
                                found_generation_element, generation_element),
                            false, _, _, true));
 
-    form_manager->ProvisionallySave(
+    form_manager.ProvisionallySave(
         submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-    form_manager->Save();
+    form_manager.Save();
   }
 }
 
 TEST_F(PasswordFormManagerTest, FieldPropertiesMasksUpload) {
   PasswordForm form(*observed_form());
   form.form_data = saved_match()->form_data;
 
   // Create submitted form.
   PasswordForm submitted_form(form);
   submitted_form.preferred = true;
   submitted_form.username_value = saved_match()->username_value;
   submitted_form.password_value = saved_match()->password_value;
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), form,
-          base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+  PasswordFormManager form_manager(
+      password_manager(), client(), client()->driver(), form,
+      base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
   fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
   DCHECK_EQ(3U, form.form_data.fields.size());
   submitted_form.form_data.fields[1].properties_mask =
       FieldPropertiesFlags::USER_TYPED;
   submitted_form.form_data.fields[2].properties_mask =
       FieldPropertiesFlags::USER_TYPED;
 
   std::map<base::string16, autofill::FieldPropertiesMask>
       expected_field_properties;
   for (const autofill::FormFieldData& field : submitted_form.form_data.fields)
     if (field.properties_mask)
       expected_field_properties[field.name] = field.properties_mask;
 
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(
                   CheckFieldPropertiesMasksUpload(expected_field_properties),
                   false, _, _, true));
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       submitted_form, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  form_manager->Save();
+  form_manager.Save();
 }
 
 TEST_F(PasswordFormManagerTest, TestSavingAPIFormsWithSamePassword) {
   // Turn |observed_form| and |saved_match| to API created forms.
   observed_form()->username_element.clear();
   observed_form()->type = autofill::PasswordForm::TYPE_API;
   saved_match()->username_element.clear();
   saved_match()->type = autofill::PasswordForm::TYPE_API;
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &fetcher));
+  PasswordFormManager form_manager(password_manager(), client(),
+                                   client()->driver(), *observed_form(),
+                                   base::MakeUnique<MockFormSaver>(), &fetcher);
   fetcher.SetNonFederated({saved_match()}, 0u);
 
   // User submits new credentials with the same password as in already saved
   // one.
   PasswordForm credentials(*observed_form());
   credentials.username_value =
       saved_match()->username_value + ASCIIToUTF16("1");
   credentials.password_value = saved_match()->password_value;
   credentials.preferred = true;
 
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       credentials, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
 
-  EXPECT_TRUE(form_manager->IsNewLogin());
+  EXPECT_TRUE(form_manager.IsNewLogin());
 
   PasswordForm new_credentials;
-  EXPECT_CALL(MockFormSaver::Get(form_manager.get()), Save(_, _, nullptr))
+  EXPECT_CALL(MockFormSaver::Get(&form_manager), Save(_, _, nullptr))
       .WillOnce(SaveArg<0>(&new_credentials));
 
-  form_manager->Save();
+  form_manager.Save();
 
   EXPECT_EQ(saved_match()->username_value + ASCIIToUTF16("1"),
             new_credentials.username_value);
   EXPECT_EQ(saved_match()->password_value, new_credentials.password_value);
   EXPECT_EQ(base::string16(), new_credentials.username_element);
   EXPECT_EQ(autofill::PasswordForm::TYPE_API, new_credentials.type);
 }
 
 TEST_F(PasswordFormManagerTest, SkipZeroClickIntact) {
   saved_match()->skip_zero_click = true;
@@ skipping 23 matching lines @@
   ASSERT_EQ(1u, credentials_to_update.size());
   EXPECT_TRUE(credentials_to_update[0].skip_zero_click);
 }
 
 TEST_F(PasswordFormManagerTest, ProbablyAccountCreationUpload) {
   PasswordForm form(*observed_form());
   form.form_data = saved_match()->form_data;
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), form,
-          base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+  PasswordFormManager form_manager(
+      password_manager(), client(), client()->driver(), form,
+      base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
 
   PasswordForm form_to_save(form);
   form_to_save.preferred = true;
   form_to_save.username_element = ASCIIToUTF16("observed-username-field");
   form_to_save.username_value = saved_match()->username_value;
   form_to_save.password_value = saved_match()->password_value;
   form_to_save.does_look_like_signup_form = true;
 
   fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
   autofill::FormStructure pending_structure(form_to_save.form_data);
   autofill::ServerFieldTypeSet expected_available_field_types;
   std::map<base::string16, autofill::ServerFieldType> expected_types;
   expected_types[ASCIIToUTF16("full_name")] = autofill::UNKNOWN_TYPE;
   expected_types[saved_match()->username_element] = autofill::UNKNOWN_TYPE;
   expected_available_field_types.insert(
       autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD);
   expected_types[saved_match()->password_element] =
       autofill::PROBABLY_ACCOUNT_CREATION_PASSWORD;
 
   EXPECT_CALL(*client()->mock_driver()->mock_autofill_download_manager(),
               StartUploadRequest(
                   CheckUploadedAutofillTypesAndSignature(
                       pending_structure.FormSignatureAsStr(), expected_types,
                       false /* expect_generation_vote */),
                   false, expected_available_field_types, std::string(), true));
 
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  form_manager->Save();
+  form_manager.Save();
 }
 
 TEST_F(PasswordFormManagerFillOnAccountSelectTest, ProcessFrame) {
   EXPECT_CALL(*client()->mock_driver(),
               ShowInitialPasswordAccountSuggestions(_));
   fake_form_fetcher()->SetNonFederated({saved_match()}, 0u);
 }
 
 // Check that PasswordFormManager records
 // PasswordManager_LoginFollowingAutofill as part of processing a credential
@@ skipping 35 matching lines @@
           static_cast<PasswordForm::Scheme>(correct);
       const PasswordForm::Scheme kWrongScheme =
           static_cast<PasswordForm::Scheme>(wrong);
       SCOPED_TRACE(testing::Message() << "Correct scheme = " << kCorrectScheme
                                       << ", wrong scheme = " << kWrongScheme);
 
       PasswordForm observed = *observed_form();
       observed.scheme = kCorrectScheme;
       FakeFormFetcher fetcher;
       fetcher.Fetch();
-      scoped_refptr<PasswordFormManager> form_manager(
-          base::MakeRefCounted<PasswordFormManager>(
-              password_manager(), client(),
-              (kCorrectScheme == PasswordForm::SCHEME_HTML ? client()->driver()
-                                                           : nullptr),
-              observed, base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+      PasswordFormManager form_manager(
+          password_manager(), client(),
+          (kCorrectScheme == PasswordForm::SCHEME_HTML ? client()->driver()
+                                                       : nullptr),
+          observed, base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
 
       PasswordForm match = *saved_match();
       match.scheme = kCorrectScheme;
 
       PasswordForm non_match = match;
       non_match.scheme = kWrongScheme;
 
       // First try putting the correct scheme first in returned matches.
-      static_cast<FormFetcher::Consumer*>(form_manager.get())
+      static_cast<FormFetcher::Consumer*>(&form_manager)
           ->ProcessMatches({&match, &non_match}, 0u);
 
-      EXPECT_EQ(1u, form_manager->best_matches().size());
+      EXPECT_EQ(1u, form_manager.best_matches().size());
       EXPECT_EQ(kCorrectScheme,
-                form_manager->best_matches().begin()->second->scheme);
+                form_manager.best_matches().begin()->second->scheme);
 
       // Now try putting the correct scheme last in returned matches.
-      static_cast<FormFetcher::Consumer*>(form_manager.get())
+      static_cast<FormFetcher::Consumer*>(&form_manager)
           ->ProcessMatches({&non_match, &match}, 0u);
 
-      EXPECT_EQ(1u, form_manager->best_matches().size());
+      EXPECT_EQ(1u, form_manager.best_matches().size());
       EXPECT_EQ(kCorrectScheme,
-                form_manager->best_matches().begin()->second->scheme);
+                form_manager.best_matches().begin()->second->scheme);
     }
   }
 }
 
 // Ensure that DoesManage takes into consideration drivers when origins are
 // different.
 TEST_F(PasswordFormManagerTest, DoesManageDifferentOrigins) {
   for (bool same_drivers : {false, true}) {
     PasswordForm submitted_form(*observed_form());
     observed_form()->origin = GURL("http://accounts.google.com/a/Login");
@@ skipping 124 matching lines @@
 
   EXPECT_THAT(credentials_to_update, IsEmpty());
 }
 
 // Check that on changing FormFetcher, the PasswordFormManager removes itself
 // from consuming the old one.
 TEST_F(PasswordFormManagerTest, DropFetcherOnDestruction) {
   MockFormFetcher fetcher;
   FormFetcher::Consumer* added_consumer = nullptr;
   EXPECT_CALL(fetcher, AddConsumer(_)).WillOnce(SaveArg<0>(&added_consumer));
-  auto form_manager = base::MakeRefCounted<PasswordFormManager>(
+  auto form_manager = base::MakeUnique<PasswordFormManager>(
       password_manager(), client(), client()->driver(), *observed_form(),
       base::MakeUnique<MockFormSaver>(), &fetcher);
   EXPECT_EQ(form_manager.get(), added_consumer);
 
   EXPECT_CALL(fetcher, RemoveConsumer(form_manager.get()));
-  form_manager = nullptr;
+  form_manager.reset();
 }
 
 // Check that if asked to take ownership of the same FormFetcher which it had
 // consumed before, the PasswordFormManager does not add itself as a consumer
 // again.
 TEST_F(PasswordFormManagerTest, GrabFetcher_Same) {
   auto fetcher = base::MakeUnique<MockFormFetcher>();
   fetcher->Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), fetcher.get()));
+  PasswordFormManager form_manager(
+      password_manager(), client(), client()->driver(), *observed_form(),
+      base::MakeUnique<MockFormSaver>(), fetcher.get());
 
   EXPECT_CALL(*fetcher, AddConsumer(_)).Times(0);
   EXPECT_CALL(*fetcher, RemoveConsumer(_)).Times(0);
-  form_manager->GrabFetcher(std::move(fetcher));
+  form_manager.GrabFetcher(std::move(fetcher));
   // There will be a RemoveConsumer call as soon as form_manager goes out of
   // scope, but the test needs to ensure that there is none as a result of
   // GrabFetcher.
-  Mock::VerifyAndClearExpectations(form_manager->form_fetcher());
+  Mock::VerifyAndClearExpectations(form_manager.form_fetcher());
 }
 
 // Check that if asked to take ownership of a different FormFetcher than which
 // it had consumed before, the PasswordFormManager adds itself as a consumer
 // and replaces the references to the old results.
 TEST_F(PasswordFormManagerTest, GrabFetcher_Different) {
   PasswordForm old_match = *observed_form();
   old_match.username_value = ASCIIToUTF16("user1");
   old_match.password_value = ASCIIToUTF16("pass");
   fake_form_fetcher()->SetNonFederated({&old_match}, 0u);
@@ skipping 11 matching lines @@
   EXPECT_EQ(0u, form_manager()->best_matches().size());
 }
 
 // Check that on changing FormFetcher, the PasswordFormManager removes itself
 // from consuming the old one.
 TEST_F(PasswordFormManagerTest, GrabFetcher_Remove) {
   MockFormFetcher old_fetcher;
   FormFetcher::Consumer* added_consumer = nullptr;
   EXPECT_CALL(old_fetcher, AddConsumer(_))
       .WillOnce(SaveArg<0>(&added_consumer));
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<MockFormSaver>(), &old_fetcher));
-  EXPECT_EQ(form_manager.get(), added_consumer);
+  PasswordFormManager form_manager(
+      password_manager(), client(), client()->driver(), *observed_form(),
+      base::MakeUnique<MockFormSaver>(), &old_fetcher);
+  EXPECT_EQ(&form_manager, added_consumer);
 
   auto new_fetcher = base::MakeUnique<MockFormFetcher>();
-  EXPECT_CALL(*new_fetcher, AddConsumer(form_manager.get()));
-  EXPECT_CALL(old_fetcher, RemoveConsumer(form_manager.get()));
-  form_manager->GrabFetcher(std::move(new_fetcher));
+  EXPECT_CALL(*new_fetcher, AddConsumer(&form_manager));
+  EXPECT_CALL(old_fetcher, RemoveConsumer(&form_manager));
+  form_manager.GrabFetcher(std::move(new_fetcher));
 }
 
 TEST_F(PasswordFormManagerTest, UploadSignInForm_WithAutofillTypes) {
   // For newly saved passwords on a sign-in form, upload an autofill vote for a
   // username field and a autofill::PASSWORD vote for a password field.
   autofill::FormFieldData field;
   field.name = ASCIIToUTF16("Email");
   field.form_control_type = "text";
   observed_form()->form_data.fields.push_back(field);
 
   field.name = ASCIIToUTF16("Passwd");
   field.form_control_type = "password";
   observed_form()->form_data.fields.push_back(field);
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+  PasswordFormManager form_manager(
+      password_manager(), client(), client()->driver(), *observed_form(),
+      base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
   fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
   PasswordForm form_to_save(*observed_form());
   form_to_save.preferred = true;
   form_to_save.username_value = ASCIIToUTF16("test@gmail.com");
   form_to_save.password_value = ASCIIToUTF16("password");
 
   std::unique_ptr<FormStructure> uploaded_form_structure;
   auto* mock_autofill_manager =
       client()->mock_driver()->mock_autofill_manager();
   EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, true))
       .WillOnce(WithArg<0>(SaveToUniquePtr(&uploaded_form_structure)));
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  form_manager->Save();
+  form_manager.Save();
 
   ASSERT_EQ(2u, uploaded_form_structure->field_count());
   autofill::ServerFieldTypeSet expected_types = {autofill::PASSWORD};
   EXPECT_EQ(form_to_save.username_value,
             uploaded_form_structure->field(0)->value);
   EXPECT_EQ(expected_types,
             uploaded_form_structure->field(1)->possible_types());
 }
 
 // Checks that there is no upload on saving a password on a password form only
 // with 1 field.
 TEST_F(PasswordFormManagerTest, NoUploadsForSubmittedFormWithOnlyOneField) {
   autofill::FormFieldData field;
   field.name = ASCIIToUTF16("Passwd");
   field.form_control_type = "password";
   observed_form()->form_data.fields.push_back(field);
 
   FakeFormFetcher fetcher;
   fetcher.Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
-          password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher));
+  PasswordFormManager form_manager(
+      password_manager(), client(), client()->driver(), *observed_form(),
+      base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
   fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
 
   PasswordForm form_to_save(*observed_form());
   form_to_save.preferred = true;
   form_to_save.password_value = ASCIIToUTF16("password");
 
   auto* mock_autofill_manager =
       client()->mock_driver()->mock_autofill_manager();
   EXPECT_CALL(*mock_autofill_manager, StartUploadProcessPtr(_, _, _)).Times(0);
-  form_manager->ProvisionallySave(
+  form_manager.ProvisionallySave(
       form_to_save, PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES);
-  form_manager->Save();
+  form_manager.Save();
 }
 
 TEST_F(PasswordFormManagerTest,
        SuppressedHTTPSFormsHistogram_NotRecordedIfStoreWasTooSlow) {
   base::HistogramTester histogram_tester;
 
   fake_form_fetcher()->set_did_complete_querying_suppressed_forms(false);
   fake_form_fetcher()->Fetch();
-  scoped_refptr<PasswordFormManager> form_manager(
-      base::MakeRefCounted<PasswordFormManager>(
+  std::unique_ptr<PasswordFormManager> form_manager =
+      base::MakeUnique<PasswordFormManager>(
           password_manager(), client(), client()->driver(), *observed_form(),
-          base::MakeUnique<NiceMock<MockFormSaver>>(), fake_form_fetcher()));
+          base::MakeUnique<NiceMock<MockFormSaver>>(), fake_form_fetcher());
   fake_form_fetcher()->SetNonFederated(std::vector<const PasswordForm*>(), 0u);
-  form_manager = nullptr;
+  form_manager.reset();
 
   histogram_tester.ExpectUniqueSample(
       "PasswordManager.QueryingSuppressedAccountsFinished", false, 1);
   const auto sample_counts = histogram_tester.GetTotalCountsForPrefix(
       "PasswordManager.SuppressedAccount.");
   EXPECT_THAT(sample_counts, IsEmpty());
 }
 
 TEST_F(PasswordFormManagerTest, SuppressedFormsHistograms) {
   static constexpr const struct {
@@ skipping 172 matching lines @@
   // scheme of the main frame.
   ASSERT_FALSE(client()->IsMainFrameSecure());
 
   // Even if there were any suppressed HTTPS forms, they should be are ignored
   // (but there should be none in production in this case).
   FakeFormFetcher fetcher;
   fetcher.set_suppressed_https_forms({saved_match()});
   fetcher.set_did_complete_querying_suppressed_forms(true);
   fetcher.Fetch();
 
-  scoped_refptr<PasswordFormManager> form_manager =
-      base::MakeRefCounted<PasswordFormManager>(
+  std::unique_ptr<PasswordFormManager> form_manager =
+      base::MakeUnique<PasswordFormManager>(
           password_manager(), client(), client()->driver(), https_observed_form,
           base::MakeUnique<NiceMock<MockFormSaver>>(), &fetcher);
   fetcher.SetNonFederated(std::vector<const PasswordForm*>(), 0u);
-  form_manager = nullptr;
+  form_manager.reset();
 
   histogram_tester.ExpectUniqueSample(
       "PasswordManager.QueryingSuppressedAccountsFinished", true, 1);
   histogram_tester.ExpectTotalCount(
       "PasswordManager.SuppressedAccount.Generated.HTTPSNotHTTP", 0);
   histogram_tester.ExpectTotalCount(
       "PasswordManager.SuppressedAccount.Manual.HTTPSNotHTTP", 0);
   histogram_tester.ExpectTotalCount(
       "PasswordManager.SuppressedAccount.Generated.PSLMatching", 1);
   histogram_tester.ExpectTotalCount(
       "PasswordManager.SuppressedAccount.Manual.PSLMatching", 1);
   histogram_tester.ExpectTotalCount(
       "PasswordManager.SuppressedAccount.Generated.SameOrganizationName", 1);
   histogram_tester.ExpectTotalCount(
       "PasswordManager.SuppressedAccount.Manual.SameOrganizationName", 1);
 }
 
 }  // namespace password_manager