chrome/browser/password_manager: scoped_ptr -> unique_ptr

chrome/browser/password_manager/password_store_mac.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 <CoreServices/CoreServices.h>
 #include <stddef.h>
 #include <set>
 #include <string>
@@ skipping 208 matching lines @@
       } else if (!partial_match) {
         partial_match = keychain_form;
       }
     }
   }
   return partial_match;
 }
 
 // Iterates over all elements in |forms|, passes the pointed to objects to
 // |mover|, and clears |forms| efficiently. FormMover needs to be a callable
-// entity, accepting scoped_ptr<autofill::PasswordForm> as its sole argument.
+// entity, accepting std::unique_ptr<autofill::PasswordForm> as its sole
+// argument.
 template <typename FormMover>
 inline void MoveAllFormsOut(ScopedVector<autofill::PasswordForm>* forms,
                             FormMover mover) {
   for (autofill::PasswordForm* form_ptr : *forms) {
-    mover(scoped_ptr<autofill::PasswordForm>(form_ptr));
+    mover(std::unique_ptr<autofill::PasswordForm>(form_ptr));
   }
   // We moved the ownership of every form out of |forms|. For performance
   // reasons, we can just weak_clear it, instead of nullptr-ing the respective
   // elements and letting the vector's destructor to go through the list once
   // more. This was tested on a benchmark, and seemed to make a difference on
   // Mac.
   forms->weak_clear();
 }
 
 // True if the form has no password to be stored in Keychain.
@@ skipping 245 matching lines @@
          form_a.username_value == form_b.username_value;
 }
 
 // Moves entries from |forms| that represent either blacklisted or federated
 // logins into |extracted|. These two types are stored only in the LoginDatabase
 // and do not have corresponding Keychain entries.
 void ExtractNonKeychainForms(ScopedVector<autofill::PasswordForm>* forms,
                              ScopedVector<autofill::PasswordForm>* extracted) {
   extracted->reserve(extracted->size() + forms->size());
   ScopedVector<autofill::PasswordForm> remaining;
-  MoveAllFormsOut(
-      forms, [&remaining, extracted](scoped_ptr<autofill::PasswordForm> form) {
-        if (IsLoginDatabaseOnlyForm(*form))
-          extracted->push_back(std::move(form));
-        else
-          remaining.push_back(std::move(form));
-      });
+  MoveAllFormsOut(forms, [&remaining, extracted](
+                             std::unique_ptr<autofill::PasswordForm> form) {
+    if (IsLoginDatabaseOnlyForm(*form))
+      extracted->push_back(std::move(form));
+    else
+      remaining.push_back(std::move(form));
+  });
   forms->swap(remaining);
 }
 
 // Takes |keychain_forms| and |database_forms| and moves the following 2 types
 // of forms to |merged_forms|:
 //   (1) |database_forms| that by principle never have a corresponding Keychain
 //       entry (viz., blacklisted and federated logins),
 //   (2) |database_forms| which should have and do have a corresponding entry in
 //       |keychain_forms|.
 // The database forms of type (2) have their password value updated from the
 // corresponding keychain form, and all the keychain forms corresponding to some
 // database form are removed from |keychain_forms| and deleted.
 void MergePasswordForms(ScopedVector<autofill::PasswordForm>* keychain_forms,
                         ScopedVector<autofill::PasswordForm>* database_forms,
                         ScopedVector<autofill::PasswordForm>* merged_forms) {
   // Pull out the database blacklist items and federated logins, since they are
   // used as-is rather than being merged with keychain forms.
   ExtractNonKeychainForms(database_forms, merged_forms);
 
   // Merge the normal entries.
   ScopedVector<autofill::PasswordForm> unused_database_forms;
   unused_database_forms.reserve(database_forms->size());
   std::set<const autofill::PasswordForm*> used_keychain_forms;
   // Move all database forms to either |merged_forms| or
   // |unused_database_forms|, based on whether they have a match in the keychain
   // forms or not. If there is a match, add its password to the DB form and
   // mark the keychain form as used.
-  MoveAllFormsOut(database_forms, [keychain_forms, &used_keychain_forms,
-                                   merged_forms, &unused_database_forms](
-                                      scoped_ptr<autofill::PasswordForm> form) {
-    const PasswordForm* best_match =
-        BestKeychainFormForForm(*form, keychain_forms->get());
-    if (best_match) {
-      used_keychain_forms.insert(best_match);
-      form->password_value = best_match->password_value;
-      merged_forms->push_back(std::move(form));
-    } else {
-      unused_database_forms.push_back(std::move(form));
-    }
-  });
+  MoveAllFormsOut(
+      database_forms,
+      [keychain_forms, &used_keychain_forms, merged_forms,
+       &unused_database_forms](std::unique_ptr<autofill::PasswordForm> form) {
+        const PasswordForm* best_match =
+            BestKeychainFormForForm(*form, keychain_forms->get());
+        if (best_match) {
+          used_keychain_forms.insert(best_match);
+          form->password_value = best_match->password_value;
+          merged_forms->push_back(std::move(form));
+        } else {
+          unused_database_forms.push_back(std::move(form));
+        }
+      });
   database_forms->swap(unused_database_forms);
 
   // Clear out all the Keychain entries we used.
   ScopedVector<autofill::PasswordForm> unused_keychain_forms;
   unused_keychain_forms.reserve(keychain_forms->size());
   for (auto& keychain_form : *keychain_forms) {
     if (!ContainsKey(used_keychain_forms, keychain_form)) {
       unused_keychain_forms.push_back(keychain_form);
       keychain_form = nullptr;
     }
@@ skipping 36 matching lines @@
       ExtractAllKeychainItemAttributesIntoPasswordForms(&keychain_items,
                                                         keychain);
 
   // Next, compare the attributes of the PasswordForms in |database_forms|
   // against those in |item_form_pairs|, and extract password data for each
   // matching PasswordForm using its corresponding SecKeychainItemRef.
   ScopedVector<autofill::PasswordForm> unused_db_forms;
   unused_db_forms.reserve(database_forms->size());
   // Move database forms with a password stored in |keychain| to |passwords|,
   // including the password. The rest is moved to |unused_db_forms|.
-  MoveAllFormsOut(database_forms,
-                  [&keychain, &item_form_pairs, passwords, &unused_db_forms](
-                      scoped_ptr<autofill::PasswordForm> form) {
-    ScopedVector<autofill::PasswordForm> keychain_matches =
-        ExtractPasswordsMergeableWithForm(keychain, item_form_pairs, *form);
+  MoveAllFormsOut(
+      database_forms,
+      [&keychain, &item_form_pairs, passwords,
+       &unused_db_forms](std::unique_ptr<autofill::PasswordForm> form) {
+        ScopedVector<autofill::PasswordForm> keychain_matches =
+            ExtractPasswordsMergeableWithForm(keychain, item_form_pairs, *form);
 
-    ScopedVector<autofill::PasswordForm> db_form_container;
-    db_form_container.push_back(std::move(form));
-    MergePasswordForms(&keychain_matches, &db_form_container, passwords);
-    AppendSecondToFirst(&unused_db_forms, &db_form_container);
-  });
+        ScopedVector<autofill::PasswordForm> db_form_container;
+        db_form_container.push_back(std::move(form));
+        MergePasswordForms(&keychain_matches, &db_form_container, passwords);
+        AppendSecondToFirst(&unused_db_forms, &db_form_container);
+      });
   database_forms->swap(unused_db_forms);
 
   STLDeleteContainerPairSecondPointers(item_form_pairs.begin(),
                                        item_form_pairs.end());
   for (SecKeychainItemRef item : keychain_items) {
     keychain.Free(item);
   }
 }
 
 // TODO(stuartmorgan): signon_realm for proxies is not yet supported.
@@ skipping 54 matching lines @@
 ScopedVector<autofill::PasswordForm> ExtractPasswordsMergeableWithForm(
     const AppleKeychain& keychain,
     const std::vector<ItemFormPair>& item_form_pairs,
     const PasswordForm& query_form) {
   ScopedVector<autofill::PasswordForm> matches;
   for (std::vector<ItemFormPair>::const_iterator i = item_form_pairs.begin();
        i != item_form_pairs.end(); ++i) {
     if (FormIsValidAndMatchesOtherForm(query_form, *(i->second))) {
       // Create a new object, since the caller is responsible for deleting the
       // returned forms.
-      scoped_ptr<PasswordForm> form_with_password(new PasswordForm());
+      std::unique_ptr<PasswordForm> form_with_password(new PasswordForm());
       FillPasswordFormFromKeychainItem(
           keychain, *(i->first), form_with_password.get(),
           true);  // Load password attributes and data.
       // Do not include blacklisted items found in the keychain.
       if (!form_with_password->blacklisted_by_user)
         matches.push_back(std::move(form_with_password));
     }
   }
   return matches;
 }
@@ skipping 132 matching lines @@
 void MacKeychainPasswordFormAdapter::SetFindsOnlyOwnedItems(
     bool finds_only_owned) {
   finds_only_owned_ = finds_only_owned;
 }
 
 ScopedVector<autofill::PasswordForm>
 MacKeychainPasswordFormAdapter::ConvertKeychainItemsToForms(
     std::vector<SecKeychainItemRef>* items) {
   ScopedVector<autofill::PasswordForm> forms;
   for (SecKeychainItemRef item : *items) {
-    scoped_ptr<PasswordForm> form(new PasswordForm());
+    std::unique_ptr<PasswordForm> form(new PasswordForm());
     if (internal_keychain_helpers::FillPasswordFormFromKeychainItem(
             *keychain_, item, form.get(), true)) {
       forms.push_back(std::move(form));
     }
     keychain_->Free(item);
   }
   items->clear();
   return forms;
 }
 
@@ skipping 97 matching lines @@
 
 OSType MacKeychainPasswordFormAdapter::CreatorCodeForSearch() {
   return finds_only_owned_ ? base::mac::CreatorCodeForApplication() : 0;
 }
 
 #pragma mark -
 
 PasswordStoreMac::PasswordStoreMac(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner,
-    scoped_ptr<AppleKeychain> keychain)
+    std::unique_ptr<AppleKeychain> keychain)
     : password_manager::PasswordStore(main_thread_runner, db_thread_runner),
       keychain_(std::move(keychain)),
       login_metadata_db_(nullptr) {
   DCHECK(keychain_);
 }
 
 PasswordStoreMac::~PasswordStoreMac() {}
 
 void PasswordStoreMac::InitWithTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> background_task_runner) {
@@ skipping 168 matching lines @@
 PasswordStoreChangeList PasswordStoreMac::RemoveLoginsByURLAndTimeImpl(
     const base::Callback<bool(const GURL&)>& url_filter,
     base::Time delete_begin,
     base::Time delete_end) {
   PasswordStoreChangeList changes;
   ScopedVector<PasswordForm> forms_to_consider;
   ScopedVector<PasswordForm> forms_to_remove;
   if (login_metadata_db_ &&
       login_metadata_db_->GetLoginsCreatedBetween(delete_begin, delete_end,
                                                   &forms_to_consider)) {
-    MoveAllFormsOut(&forms_to_consider,
-                    [this, &url_filter, &forms_to_remove](
-                        scoped_ptr<autofill::PasswordForm> form_to_consider) {
-                      if (url_filter.Run(form_to_consider->origin) &&
-                          login_metadata_db_->RemoveLogin(*form_to_consider))
-                        forms_to_remove.push_back(std::move(form_to_consider));
-                    });
+    MoveAllFormsOut(
+        &forms_to_consider,
+        [this, &url_filter, &forms_to_remove](
+            std::unique_ptr<autofill::PasswordForm> form_to_consider) {
+          if (url_filter.Run(form_to_consider->origin) &&
+              login_metadata_db_->RemoveLogin(*form_to_consider))
+            forms_to_remove.push_back(std::move(form_to_consider));
+        });
     if (!forms_to_remove.empty()) {
       RemoveKeychainForms(forms_to_remove.get());
       CleanOrphanedForms(&forms_to_remove);  // Add the orphaned forms.
       changes = FormsToRemoveChangeList(forms_to_remove.get());
       LogStatsForBulkDeletion(changes.size());
     }
   }
   return changes;
 }
 
@@ skipping 134 matching lines @@
   if (login_metadata_db_)
     login_metadata_db_->stats_table().AddRow(stats);
 }
 
 void PasswordStoreMac::RemoveSiteStatsImpl(const GURL& origin_domain) {
   DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   if (login_metadata_db_)
     login_metadata_db_->stats_table().RemoveRow(origin_domain);
 }
 
-std::vector<scoped_ptr<password_manager::InteractionsStats>>
+std::vector<std::unique_ptr<password_manager::InteractionsStats>>
 PasswordStoreMac::GetSiteStatsImpl(const GURL& origin_domain) {
   DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   return login_metadata_db_
              ? login_metadata_db_->stats_table().GetRows(origin_domain)
-             : std::vector<scoped_ptr<password_manager::InteractionsStats>>();
+             : std::vector<
+                   std::unique_ptr<password_manager::InteractionsStats>>();
 }
 
 bool PasswordStoreMac::AddToKeychainIfNecessary(const PasswordForm& form) {
   if (IsLoginDatabaseOnlyForm(form))
     return true;
   MacKeychainPasswordFormAdapter keychainAdapter(keychain_.get());
   return keychainAdapter.AddPassword(form);
 }
 
 bool PasswordStoreMac::DatabaseHasFormMatchingKeychainForm(
@@ skipping 15 matching lines @@
     }
   }
   return has_match;
 }
 
 void PasswordStoreMac::RemoveDatabaseForms(
   ScopedVector<autofill::PasswordForm>* forms) {
   DCHECK(login_metadata_db_);
   ScopedVector<autofill::PasswordForm> removed_forms;
   MoveAllFormsOut(forms, [this, &removed_forms](
-                             scoped_ptr<autofill::PasswordForm> form) {
+                             std::unique_ptr<autofill::PasswordForm> form) {
     if (login_metadata_db_->RemoveLogin(*form))
       removed_forms.push_back(std::move(form));
   });
   removed_forms.swap(*forms);
 }
 
 void PasswordStoreMac::RemoveKeychainForms(
     const std::vector<PasswordForm*>& forms) {
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_.get());
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
@@ skipping 16 matching lines @@
   ScopedVector<PasswordForm> forms_with_keychain_entry;
   internal_keychain_helpers::GetPasswordsForForms(*keychain_, &database_forms,
                                                   &forms_with_keychain_entry);
 
   // Clean up any orphaned database entries.
   RemoveDatabaseForms(&database_forms);
 
   // Move the orphaned DB forms to the output parameter.
   AppendSecondToFirst(orphaned_forms, &database_forms);
 }