components/password_manager: scoped_ptr -> unique_ptr

components/password_manager/content/browser/credential_manager_dispatcher_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/password_manager/content/browser/credential_manager_dispatcher.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <tuple>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/core/browser/credential_manager_password_form_manager.h"
 #include "components/password_manager/core/browser/mock_affiliated_match_helper.h"
 #include "components/password_manager/core/browser/password_manager.h"
 #include "components/password_manager/core/browser/stub_password_manager_client.h"
 #include "components/password_manager/core/browser/stub_password_manager_driver.h"
@@ skipping 42 matching lines @@
                     const CredentialsCallback& callback));
 
   explicit MockPasswordManagerClient(PasswordStore* store) : store_(store) {
     prefs_.registry()->RegisterBooleanPref(prefs::kCredentialsEnableAutosignin,
                                            true);
     prefs_.registry()->RegisterBooleanPref(
         prefs::kWasAutoSignInFirstRunExperienceShown, true);
   }
   ~MockPasswordManagerClient() override {}
 
-  bool PromptUserToSaveOrUpdatePassword(scoped_ptr<PasswordFormManager> manager,
-                                        CredentialSourceType type,
-                                        bool update_password) override {
+  bool PromptUserToSaveOrUpdatePassword(
+      std::unique_ptr<PasswordFormManager> manager,
+      CredentialSourceType type,
+      bool update_password) override {
     manager_.swap(manager);
     PromptUserToSavePasswordPtr(manager_.get(), type);
     return true;
   }
 
   void NotifyUserCouldBeAutoSignedIn(
-      scoped_ptr<autofill::PasswordForm> form) override {
+      std::unique_ptr<autofill::PasswordForm> form) override {
     NotifyUserCouldBeAutoSignedInPtr(form.get());
   }
 
   PasswordStore* GetPasswordStore() const override { return store_; }
 
   PrefService* GetPrefs() override { return &prefs_; }
 
   bool PromptUserToChooseCredentials(
       ScopedVector<autofill::PasswordForm> local_forms,
       ScopedVector<autofill::PasswordForm> federated_forms,
@@ skipping 23 matching lines @@
   }
 
   void set_first_run_seen(bool first_run_seen) {
     prefs_.SetBoolean(prefs::kWasAutoSignInFirstRunExperienceShown,
                       first_run_seen);
   }
 
  private:
   TestingPrefServiceSimple prefs_;
   PasswordStore* store_;
-  scoped_ptr<PasswordFormManager> manager_;
+  std::unique_ptr<PasswordFormManager> manager_;
 
   DISALLOW_COPY_AND_ASSIGN(MockPasswordManagerClient);
 };
 
 class TestCredentialManagerDispatcher : public CredentialManagerDispatcher {
  public:
   TestCredentialManagerDispatcher(content::WebContents* web_contents,
                                   PasswordManagerClient* client,
                                   PasswordManagerDriver* driver);
 
@@ skipping 150 matching lines @@
 
   CredentialManagerDispatcher* dispatcher() { return dispatcher_.get(); }
 
  protected:
   autofill::PasswordForm form_;
   autofill::PasswordForm affiliated_form1_;
   autofill::PasswordForm affiliated_form2_;
   autofill::PasswordForm origin_path_form_;
   autofill::PasswordForm cross_origin_form_;
   scoped_refptr<TestPasswordStore> store_;
-  scoped_ptr<testing::NiceMock<MockPasswordManagerClient>> client_;
-  scoped_ptr<SlightlyLessStubbyPasswordManagerDriver> stub_driver_;
-  scoped_ptr<CredentialManagerDispatcher> dispatcher_;
+  std::unique_ptr<testing::NiceMock<MockPasswordManagerClient>> client_;
+  std::unique_ptr<SlightlyLessStubbyPasswordManagerDriver> stub_driver_;
+  std::unique_ptr<CredentialManagerDispatcher> dispatcher_;
 };
 
 TEST_F(CredentialManagerDispatcherTest, IsZeroClickAllowed) {
   // IsZeroClickAllowed is uneffected by the first-run status.
   client_->set_zero_click_enabled(true);
   client_->set_first_run_seen(true);
   EXPECT_TRUE(dispatcher()->IsZeroClickAllowed());
 
   client_->set_zero_click_enabled(true);
   client_->set_first_run_seen(false);
@@ skipping 208 matching lines @@
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequireUserMediationWithAffiliation) {
   store_->AddLogin(form_);
   store_->AddLogin(cross_origin_form_);
   store_->AddLogin(affiliated_form1_);
   store_->AddLogin(affiliated_form2_);
 
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
   RunAllPendingTasks();
 
@@ skipping 161 matching lines @@
   EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInFailure();
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialAffiliatedPasswordMatch) {
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
   // We pass in 'true' for the 'include_passwords' argument to ensure that
   // password-type credentials are included as potential matches.
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInSuccess(CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialAffiliatedPasswordNoMatch) {
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
   // We pass in 'false' for the 'include_passwords' argument to ensure that
   // password-type credentials are excluded as potential matches.
   dispatcher()->OnRequestCredential(kRequestId, true, false, federations);
 
   ExpectZeroClickSignInFailure();
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialAffiliatedFederatedMatch) {
   affiliated_form1_.federation_origin =
       url::Origin(GURL("https://example.com/"));
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://example.com/"));
 
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInSuccess(CredentialType::CREDENTIAL_TYPE_FEDERATED);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialAffiliatedFederatedNoMatch) {
   affiliated_form1_.federation_origin =
       url::Origin(GURL("https://example.com/"));
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://not-example.com/"));
 
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
@@ skipping 269 matching lines @@
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, std::get<1>(param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        ZeroClickWithAffiliatedFormInPasswordStore) {
   // Insert the affiliated form into the store, and mock out the association
   // with the current origin. As it's the only form matching the origin, it
   // ought to be returned automagically.
   store_->AddLogin(affiliated_form1_);
 
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInSuccess(CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        ZeroClickWithTwoAffiliatedFormsInPasswordStore) {
   // Insert two affiliated forms into the store, and mock out the association
   // with the current origin. Multiple forms === no zero-click sign in.
   store_->AddLogin(affiliated_form1_);
   store_->AddLogin(affiliated_form2_);
 
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   affiliated_realms.push_back(kTestAndroidRealm1);
   affiliated_realms.push_back(kTestAndroidRealm2);
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInFailure();
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        ZeroClickWithUnaffiliatedFormsInPasswordStore) {
   // Insert the affiliated form into the store, but don't mock out the
   // association with the current origin. No association === no zero-click sign
   // in.
   store_->AddLogin(affiliated_form1_);
 
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInFailure();
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        ZeroClickWithFormAndUnaffiliatedFormsInPasswordStore) {
   // Insert the affiliated form into the store, along with a real form for the
   // origin, and don't mock out the association with the current origin. No
   // association + existing form === zero-click sign in.
   store_->AddLogin(form_);
   store_->AddLogin(affiliated_form1_);
 
-  auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
+  auto mock_helper = base::WrapUnique(new MockAffiliatedMatchHelper);
   store_->SetAffiliatedMatchHelper(std::move(mock_helper));
 
   std::vector<GURL> federations;
   std::vector<std::string> affiliated_realms;
   static_cast<MockAffiliatedMatchHelper*>(store_->affiliated_match_helper())
       ->ExpectCallToGetAffiliatedAndroidRealms(
           dispatcher_->GetSynthesizedFormForOrigin(), affiliated_realms);
 
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInSuccess(CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerDispatcherTest, GetSynthesizedFormForOrigin) {
   autofill::PasswordForm synthesized =
       dispatcher_->GetSynthesizedFormForOrigin();
   EXPECT_EQ(kTestWebOrigin, synthesized.origin.spec());
   EXPECT_EQ(kTestWebOrigin, synthesized.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, synthesized.scheme);
   EXPECT_TRUE(synthesized.ssl_valid);
 }
 
 }  // namespace password_manager