chrome/browser/password_manager: scoped_ptr -> unique_ptr

chrome/browser/password_manager/password_store_mac_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 "chrome/browser/password_manager/password_store_mac.h"
 
 #include <stddef.h>
 
 #include <string>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/histogram_tester.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/password_manager/password_store_mac_internal.h"
 #include "chrome/common/chrome_paths.h"
 #include "components/os_crypt/os_crypt.h"
@@ skipping 161 matching lines @@
 
  private:
   void Initialize();
 
   void ClosePasswordStore();
 
   base::FilePath test_login_db_file_path() const;
 
   base::MessageLoopForUI message_loop_;
   base::ScopedTempDir db_dir_;
-  scoped_ptr<LoginDatabase> login_db_;
+  std::unique_ptr<LoginDatabase> login_db_;
   scoped_refptr<PasswordStoreMac> store_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordStoreMacTestDelegate);
 };
 
 PasswordStoreMacTestDelegate::PasswordStoreMacTestDelegate() {
   Initialize();
 }
 
 PasswordStoreMacTestDelegate::~PasswordStoreMacTestDelegate() {
   ClosePasswordStore();
 }
 
 void PasswordStoreMacTestDelegate::FinishAsyncProcessing() {
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 void PasswordStoreMacTestDelegate::Initialize() {
   ASSERT_TRUE(db_dir_.CreateUniqueTempDir());
 
   // Ensure that LoginDatabase will use the mock keychain if it needs to
   // encrypt/decrypt a password.
   OSCrypt::UseMockKeychain(true);
   login_db_.reset(new LoginDatabase(test_login_db_file_path()));
   ASSERT_TRUE(login_db_->Init());
 
   // Create and initialize the password store.
   store_ = new PasswordStoreMac(base::ThreadTaskRunnerHandle::Get(),
                                 base::ThreadTaskRunnerHandle::Get(),
-                                make_scoped_ptr(new MockAppleKeychain));
+                                base::WrapUnique(new MockAppleKeychain));
   store_->set_login_metadata_db(login_db_.get());
   store_->login_metadata_db()->set_clear_password_values(false);
 }
 
 void PasswordStoreMacTestDelegate::ClosePasswordStore() {
   store_->ShutdownOnUIThread();
   FinishAsyncProcessing();
 }
 
 base::FilePath PasswordStoreMacTestDelegate::test_login_db_file_path() const {
@@ skipping 326 matching lines @@
     /// Garbage forms should have no matches.
     { { PasswordForm::SCHEME_HTML, "foo/bar/baz",
         NULL, NULL, NULL, NULL, NULL, NULL, NULL, false, false, 0 }, 0, 0 },
   };
   /* clang-format on */
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   for (unsigned int i = 0; i < arraysize(test_data); ++i) {
-    scoped_ptr<PasswordForm> query_form =
+    std::unique_ptr<PasswordForm> query_form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
 
     // Check matches treating the form as a fill target.
     ScopedVector<autofill::PasswordForm> matching_items =
         keychain_adapter.PasswordsFillingForm(query_form->signon_realm,
                                               query_form->scheme);
     EXPECT_EQ(test_data[i].expected_fill_matches, matching_items.size());
 
     // Check matches treating the form as a merging target.
     EXPECT_EQ(test_data[i].expected_merge_matches > 0,
@@ skipping 58 matching lines @@
     { PasswordForm::SCHEME_BASIC, "http://some.domain.com:4567/low_security",
       "http://some.domain.com:4567/insecure.html",
       NULL, NULL, NULL, NULL, L"basic_auth_user", NULL, true, false, 0 },
     { PasswordForm::SCHEME_DIGEST, "https://some.domain.com/high_security",
       "https://some.domain.com",
       NULL, NULL, NULL, NULL, L"digest_auth_user", NULL, true, true, 0 },
   };
 
   for (unsigned int i = 0; i < arraysize(base_form_data); ++i) {
     // Create a base form and make sure we find a match.
-    scoped_ptr<PasswordForm> base_form =
+    std::unique_ptr<PasswordForm> base_form =
         CreatePasswordFormFromDataForTesting(base_form_data[i]);
     EXPECT_TRUE(keychain_adapter.HasPasswordsMergeableWithForm(*base_form));
     EXPECT_TRUE(keychain_adapter.HasPasswordExactlyMatchingForm(*base_form));
 
     // Make sure that the matching isn't looser than it should be by checking
     // that slightly altered forms don't match.
     ScopedVector<autofill::PasswordForm> modified_forms;
 
     modified_forms.push_back(new PasswordForm(*base_form));
     modified_forms.back()->username_value = ASCIIToUTF16("wrong_user");
@@ skipping 63 matching lines @@
     { { PasswordForm::SCHEME_HTML, "http://some.domain.com",
         "http://some.domain.com/insecure.html", NULL, NULL, NULL, NULL,
         L"joe_user", L"fail_me", false, false, 0 }, false },
   };
   /* clang-format on */
 
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   for (unsigned int i = 0; i < arraysize(test_data); ++i) {
-    scoped_ptr<PasswordForm> in_form =
+    std::unique_ptr<PasswordForm> in_form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
     bool add_succeeded = owned_keychain_adapter.AddPassword(*in_form);
     EXPECT_EQ(test_data[i].should_succeed, add_succeeded);
     if (add_succeeded) {
       EXPECT_TRUE(owned_keychain_adapter.HasPasswordsMergeableWithForm(
           *in_form));
       EXPECT_TRUE(owned_keychain_adapter.HasPasswordExactlyMatchingForm(
           *in_form));
     }
   }
 
   // Test that adding duplicate item updates the existing item.
   // TODO(engedy): Add a test to verify that updating Android credentials work.
   // See: https://crbug.com/476851.
   {
     PasswordFormData data = {
       PasswordForm::SCHEME_HTML, "http://some.domain.com",
       "http://some.domain.com/insecure.html", NULL,
       NULL, NULL, NULL, L"joe_user", L"updated_password", false, false, 0
     };
-    scoped_ptr<PasswordForm> update_form =
+    std::unique_ptr<PasswordForm> update_form =
         CreatePasswordFormFromDataForTesting(data);
     MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
     EXPECT_TRUE(keychain_adapter.AddPassword(*update_form));
     SecKeychainItemRef keychain_item = reinterpret_cast<SecKeychainItemRef>(2);
     PasswordForm stored_form;
     internal_keychain_helpers::FillPasswordFormFromKeychainItem(*keychain_,
                                                                 keychain_item,
                                                                 &stored_form,
                                                                 true);
     EXPECT_EQ(update_form->password_value, stored_form.password_value);
@@ skipping 24 matching lines @@
         "http://some.domain.com/insecure.html", NULL, NULL, NULL, NULL,
         L"joe_user", NULL, true, false, 0 }, false },
   };
   /* clang-format on */
 
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   // Add our test items (except the last one) so that we can delete them.
   for (unsigned int i = 0; i + 1 < arraysize(test_data); ++i) {
-    scoped_ptr<PasswordForm> add_form =
+    std::unique_ptr<PasswordForm> add_form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
     EXPECT_TRUE(owned_keychain_adapter.AddPassword(*add_form));
   }
 
   for (unsigned int i = 0; i < arraysize(test_data); ++i) {
-    scoped_ptr<PasswordForm> form =
+    std::unique_ptr<PasswordForm> form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
     EXPECT_EQ(test_data[i].should_succeed,
               owned_keychain_adapter.RemovePassword(*form));
 
     MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
     bool match = keychain_adapter.HasPasswordExactlyMatchingForm(*form);
     EXPECT_EQ(test_data[i].should_succeed, !match);
   }
 }
 
@@ skipping 403 matching lines @@
       "http://web.site.com/path/to/page.html", NULL, NULL, NULL, NULL,
       L"anonymous", L"knock-knock", false, false, 0 },
     { PasswordForm::SCHEME_BASIC, "http://a.site.com:2222/therealm",
       "http://a.site.com:2222/", NULL, NULL, NULL, NULL,
       L"username", L"password", false, false, 0 },
     { PasswordForm::SCHEME_DIGEST, "https://digest.site.com/differentrealm",
       "https://digest.site.com/secure.html", NULL, NULL, NULL, NULL,
       L"testname", L"testpass", false, false, 0 },
   };
   for (unsigned int i = 0; i < arraysize(owned_password_data); ++i) {
-    scoped_ptr<PasswordForm> form =
+    std::unique_ptr<PasswordForm> form =
         CreatePasswordFormFromDataForTesting(owned_password_data[i]);
     owned_keychain_adapter.AddPassword(*form);
   }
 
   ScopedVector<autofill::PasswordForm> all_passwords =
       keychain_adapter.GetAllPasswordFormPasswords();
   EXPECT_EQ(9 + arraysize(owned_password_data), all_passwords.size());
 
   ScopedVector<autofill::PasswordForm> owned_passwords =
       owned_keychain_adapter.GetAllPasswordFormPasswords();
@@ skipping 39 matching lines @@
     }
   }
 
   static void InitLoginDatabase(password_manager::LoginDatabase* login_db) {
     ASSERT_TRUE(login_db->Init());
   }
 
   void CreateAndInitPasswordStore(password_manager::LoginDatabase* login_db) {
     store_ = new PasswordStoreMac(
         base::ThreadTaskRunnerHandle::Get(), nullptr,
-        make_scoped_ptr<AppleKeychain>(new MockAppleKeychain));
+        base::WrapUnique<AppleKeychain>(new MockAppleKeychain));
     ASSERT_TRUE(thread_->task_runner()->PostTask(
         FROM_HERE, base::Bind(&PasswordStoreMac::InitWithTaskRunner, store_,
                               thread_->task_runner())));
 
     ASSERT_TRUE(thread_->task_runner()->PostTask(
         FROM_HERE, base::Bind(&PasswordStoreMac::set_login_metadata_db, store_,
                               base::Unretained(login_db))));
   }
 
   void ClosePasswordStore() {
@@ skipping 72 matching lines @@
         FROM_HERE, base::Bind(&Noop), runner->QuitClosure()));
     runner->Run();
   }
 
   PasswordStoreMac* store() { return store_.get(); }
 
  protected:
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   // Thread that the synchronous methods are run on.
-  scoped_ptr<base::Thread> thread_;
+  std::unique_ptr<base::Thread> thread_;
 
   base::ScopedTempDir db_dir_;
-  scoped_ptr<password_manager::LoginDatabase> login_db_;
+  std::unique_ptr<password_manager::LoginDatabase> login_db_;
   scoped_refptr<PasswordStoreMac> store_;
-  scoped_ptr<base::HistogramTester> histogram_tester_;
+  std::unique_ptr<base::HistogramTester> histogram_tester_;
 };
 
 TEST_F(PasswordStoreMacTest, TestStoreUpdate) {
   // Insert a password into both the database and the keychain.
   // This is done manually, rather than through store_->AddLogin, because the
   // Mock Keychain isn't smart enough to be able to support update generically,
   // so some.domain.com triggers special handling to test it that make inserting
   // fail.
   PasswordFormData joint_data = {
     PasswordForm::SCHEME_HTML, "http://some.domain.com/",
     "http://some.domain.com/insecure.html", "login.cgi",
     L"username", L"password", L"submit", L"joe_user", L"sekrit", true, false, 1
   };
-  scoped_ptr<PasswordForm> joint_form =
+  std::unique_ptr<PasswordForm> joint_form =
       CreatePasswordFormFromDataForTesting(joint_data);
   EXPECT_EQ(AddChangeForForm(*joint_form), login_db()->AddLogin(*joint_form));
   MockAppleKeychain::KeychainTestData joint_keychain_data = {
     kSecAuthenticationTypeHTMLForm, "some.domain.com",
     kSecProtocolTypeHTTP, "/insecure.html", 0, NULL, "20020601171500Z",
     "joe_user", "sekrit", false };
   keychain()->AddTestItem(joint_keychain_data);
 
   // Insert a password into the keychain only.
   MockAppleKeychain::KeychainTestData keychain_only_data = {
@@ skipping 29 matching lines @@
     // case where a form is filled, then the stored login is removed, then the
     // form is submitted.
     { { PasswordForm::SCHEME_HTML, "http://different.com/",
         "http://different.com/index.html", "login.cgi",
         L"username", L"password", L"submit", L"abc", L"123",
         true, false, 2 },
       NULL,
     },
   };
   for (unsigned int i = 0; i < arraysize(updates); ++i) {
-    scoped_ptr<PasswordForm> form =
+    std::unique_ptr<PasswordForm> form =
         CreatePasswordFormFromDataForTesting(updates[i].form_data);
     store_->UpdateLogin(*form);
   }
 
   FinishAsyncProcessing();
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain());
   for (unsigned int i = 0; i < arraysize(updates); ++i) {
-    scoped_ptr<PasswordForm> query_form =
+    std::unique_ptr<PasswordForm> query_form =
         CreatePasswordFormFromDataForTesting(updates[i].form_data);
 
     ScopedVector<autofill::PasswordForm> matching_items =
         keychain_adapter.PasswordsFillingForm(query_form->signon_realm,
                                               query_form->scheme);
     if (updates[i].password) {
       EXPECT_GT(matching_items.size(), 0U) << "iteration " << i;
       if (matching_items.size() >= 1)
         EXPECT_EQ(ASCIIToUTF16(updates[i].password),
                   matching_items[0]->password_value) << "iteration " << i;
@@ skipping 22 matching lines @@
   // www.facebook.com password from the login database, we should not be blocked
   // from deleting it from the keystore just becaus the m.facebook.com password
   // fuzzy-matches the www.facebook.com one.)
 
   // 1. Add a password for www.facebook.com
   PasswordFormData www_form_data = {
     PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
     "http://www.facebook.com/index.html", "login",
     L"username", L"password", L"submit", L"joe_user", L"sekrit", true, false, 1
   };
-  scoped_ptr<PasswordForm> www_form =
+  std::unique_ptr<PasswordForm> www_form =
       CreatePasswordFormFromDataForTesting(www_form_data);
   EXPECT_EQ(AddChangeForForm(*www_form), login_db()->AddLogin(*www_form));
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain());
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   owned_keychain_adapter.AddPassword(*www_form);
 
   // 2. Get a password for m.facebook.com.
   PasswordForm m_form(*www_form);
   m_form.signon_realm = "http://m.facebook.com";
   m_form.origin = GURL("http://m.facebook.com/index.html");
@@ skipping 72 matching lines @@
       L"password", L"joe_user", L"sekrit", true, false, 0 };
   // The old form doesn't have elements names.
   PasswordFormData www_form_data_facebook_old = {
       PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
       "http://www.facebook.com/index.html", "login", L"", L"",
       L"", L"joe_user", L"oldsekrit", true, false, 0 };
   PasswordFormData www_form_data_other = {
       PasswordForm::SCHEME_HTML, "http://different.com/",
       "http://different.com/index.html", "login", L"submit", L"username",
       L"password", L"different_joe_user", L"sekrit", true, false, 0 };
-  scoped_ptr<PasswordForm> form_facebook =
+  std::unique_ptr<PasswordForm> form_facebook =
       CreatePasswordFormFromDataForTesting(www_form_data_facebook);
-  scoped_ptr<PasswordForm> form_facebook_old =
+  std::unique_ptr<PasswordForm> form_facebook_old =
       CreatePasswordFormFromDataForTesting(www_form_data_facebook_old);
-  scoped_ptr<PasswordForm> form_other =
+  std::unique_ptr<PasswordForm> form_other =
       CreatePasswordFormFromDataForTesting(www_form_data_other);
   base::Time now = base::Time::Now();
   base::Time next_day = now + base::TimeDelta::FromDays(1);
   if (check_created) {
     form_facebook_old->date_created = now;
     form_facebook->date_created = next_day;
     form_other->date_created = next_day;
   } else {
     form_facebook_old->date_synced = now;
     form_facebook->date_synced = next_day;
@@ skipping 79 matching lines @@
       "http://www.facebook.com/index.html",
       "login",
       L"submit",
       L"username",
       L"password",
       L"joe_user",
       L"sekrit",
       true,
       false,
       0};
-  scoped_ptr<PasswordForm> form_facebook =
+  std::unique_ptr<PasswordForm> form_facebook =
       CreatePasswordFormFromDataForTesting(www_form_data_facebook);
   form_facebook->skip_zero_click = false;
 
   // Add the zero-clickable form to the database.
   PasswordsChangeObserver observer(store());
   store()->AddLogin(*form_facebook);
   EXPECT_CALL(observer, OnLoginsChanged(GetAddChangeList(*form_facebook)));
   observer.WaitAndVerify(this);
 
   ScopedVector<autofill::PasswordForm> forms;
@@ skipping 20 matching lines @@
   keychain()->AddTestItem(keychain_data);
 
   // Add a password through the adapter. It has the "Chrome" creator tag.
   // However, it's not referenced by the password database.
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain());
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   PasswordFormData www_form_data1 = {
       PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
       "http://www.facebook.com/index.html", "login", L"username", L"password",
       L"submit", L"joe_user", L"sekrit", true, false, 1 };
-  scoped_ptr<PasswordForm> www_form =
+  std::unique_ptr<PasswordForm> www_form =
       CreatePasswordFormFromDataForTesting(www_form_data1);
   EXPECT_TRUE(owned_keychain_adapter.AddPassword(*www_form));
 
   // Add a password from the current profile.
   PasswordFormData www_form_data2 = {
       PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
       "http://www.facebook.com/index.html", "login", L"username", L"password",
       L"submit", L"not_joe_user", L"12345", true, false, 1 };
   www_form = CreatePasswordFormFromDataForTesting(www_form_data2);
   store_->AddLogin(*www_form);
@@ skipping 31 matching lines @@
   testing::StrictMock<password_manager::MockPasswordStoreObserver>
       mock_observer;
   store()->AddObserver(&mock_observer);
 
   // 1. Add a password for www.facebook.com to the LoginDatabase.
   PasswordFormData www_form_data = {
     PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
     "http://www.facebook.com/index.html", "login",
     L"username", L"password", L"submit", L"joe_user", L"", true, false, 1
   };
-  scoped_ptr<PasswordForm> www_form(
+  std::unique_ptr<PasswordForm> www_form(
       CreatePasswordFormFromDataForTesting(www_form_data));
   EXPECT_EQ(AddChangeForForm(*www_form), login_db()->AddLogin(*www_form));
 
   // 2. Get a PSL-matched password for m.facebook.com. The observer isn't
   // notified because the form isn't in the database.
   PasswordForm m_form(*www_form);
   m_form.signon_realm = "http://m.facebook.com";
   m_form.origin = GURL("http://m.facebook.com/index.html");
 
   MockPasswordStoreConsumer consumer;
@@ skipping 158 matching lines @@
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumPasswordsOnFailure", 1, 1);
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumFailedPasswords", 1, 1);
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumChromeOwnedInaccessiblePasswords",
       2, 1);
   // Don't test the encryption key access.
   histogram_tester_.reset();
 }