Remove stl_util's STLDeleteContainerPairSecondPointers.

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 <algorithm>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/mac/security_wrappers.h"
 #include "chrome/browser/password_manager/password_store_mac_internal.h"
 #include "components/os_crypt/os_crypt.h"
 #include "components/password_manager/core/browser/affiliation_utils.h"
 #include "components/password_manager/core/browser/login_database.h"
 #include "components/password_manager/core/browser/password_manager_util.h"
 #include "components/password_manager/core/browser/password_store_change.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/apple_keychain.h"
 #include "url/origin.h"
 
 using autofill::PasswordForm;
 using crypto::AppleKeychain;
 using password_manager::PasswordStoreChange;
 using password_manager::PasswordStoreChangeList;
 
 namespace {
 
 // Utility class to handle the details of constructing and running a keychain
 // search from a set of attributes.
 class KeychainSearch {
  public:
   explicit KeychainSearch(const AppleKeychain& keychain);
   ~KeychainSearch();
 
-  // Sets up a keycahin search based on an non "null" (NULL for char*,
+  // Sets up a keychain search based on an non "null" (NULL for char*,
   // The appropriate "Any" entry for other types) arguments.
   //
-  // IMPORTANT: Any paramaters passed in *must* remain valid for as long as the
+  // IMPORTANT: Any parameters passed in *must* remain valid for as long as the
   // KeychainSearch object, since the search uses them by reference.
   void Init(const char* server,
             const UInt32* port,
             const SecProtocolType* protocol,
             const SecAuthenticationType* auth_type,
             const char* security_domain,
             const char* path,
             const char* username,
             const OSType* creator);
 
@@ skipping 254 matching lines @@
 PasswordForm::Scheme SchemeForAuthType(SecAuthenticationType auth_type) {
   switch (auth_type) {
     case kSecAuthenticationTypeHTMLForm:   return PasswordForm::SCHEME_HTML;
     case kSecAuthenticationTypeHTTPBasic:  return PasswordForm::SCHEME_BASIC;
     case kSecAuthenticationTypeHTTPDigest: return PasswordForm::SCHEME_DIGEST;
     default:                               return PasswordForm::SCHEME_OTHER;
   }
 }
 
 bool FillPasswordFormFromKeychainItem(const AppleKeychain& keychain,
-                                      const SecKeychainItemRef& keychain_item,
+                                      SecKeychainItemRef keychain_item,
                                       PasswordForm* form,
                                       bool extract_password_data) {
   DCHECK(form);
 
   SecKeychainAttributeInfo attrInfo;
   UInt32 tags[] = { kSecAccountItemAttr,
                     kSecServerItemAttr,
                     kSecPortItemAttr,
                     kSecPathItemAttr,
                     kSecProtocolItemAttr,
@@ skipping 111 matching lines @@
     // format.
     form->signon_realm = form->origin.GetOrigin().spec();
     if (form->scheme != PasswordForm::SCHEME_HTML) {
       form->signon_realm.append(security_domain);
     }
   }
   return true;
 }
 
 bool HasChromeCreatorCode(const AppleKeychain& keychain,
-                          const SecKeychainItemRef& keychain_item) {
+                          SecKeychainItemRef keychain_item) {
   SecKeychainAttributeInfo attr_info;
   UInt32 tags[] = {kSecCreatorItemAttr};
   attr_info.count = arraysize(tags);
   attr_info.tag = tags;
   attr_info.format = nullptr;
 
   SecKeychainAttributeList* attr_list;
   UInt32 password_length;
   OSStatus result = keychain.ItemCopyAttributesAndData(
       keychain_item, &attr_info, nullptr, &attr_list,
@@ skipping 98 matching lines @@
   keychain_forms->swap(unused_keychain_forms);
 }
 
 std::vector<ItemFormPair> ExtractAllKeychainItemAttributesIntoPasswordForms(
     std::vector<SecKeychainItemRef>* keychain_items,
     const AppleKeychain& keychain) {
   DCHECK(keychain_items);
   MacKeychainPasswordFormAdapter keychain_adapter(&keychain);
   *keychain_items = keychain_adapter.GetAllPasswordFormKeychainItems();
   std::vector<ItemFormPair> item_form_pairs;
-  for (std::vector<SecKeychainItemRef>::iterator i = keychain_items->begin();
-       i != keychain_items->end(); ++i) {
-    PasswordForm* form_without_password = new PasswordForm();
+  for (const auto& keychain_item : *keychain_items) {
+    std::unique_ptr<PasswordForm> form_without_password =
+        base::MakeUnique<PasswordForm>();
     internal_keychain_helpers::FillPasswordFormFromKeychainItem(
-        keychain,
-        *i,
-        form_without_password,
+        keychain, keychain_item, form_without_password.get(),
         false);  // Load password attributes, but not password data.
-    item_form_pairs.push_back(std::make_pair(&(*i), form_without_password));
+    item_form_pairs.push_back(
+        std::make_pair(keychain_item, std::move(form_without_password)));
   }
   return item_form_pairs;
 }
 
 void GetPasswordsForForms(const AppleKeychain& keychain,
                           ScopedVector<autofill::PasswordForm>* database_forms,
                           ScopedVector<autofill::PasswordForm>* passwords) {
   // First load the attributes of all items in the keychain without loading
   // their password data, and then match items in |database_forms| against them.
   // This avoids individually searching through the keychain for passwords
@@ skipping 20 matching lines @@
         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);
       });
   database_forms->swap(unused_db_forms);
 
-  base::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.
 bool ExtractSignonRealmComponents(const std::string& signon_realm,
                                   std::string* server,
                                   UInt32* port,
                                   bool* is_secure,
@@ skipping 52 matching lines @@
     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.
       std::unique_ptr<PasswordForm> form_with_password(new PasswordForm());
       FillPasswordFormFromKeychainItem(
-          keychain, *(i->first), form_with_password.get(),
+          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;
 }
 
 }  // namespace internal_keychain_helpers
@@ skipping 25 matching lines @@
 }
 
 bool MacKeychainPasswordFormAdapter::HasPasswordsMergeableWithForm(
     const PasswordForm& query_form) {
   if (IsLoginDatabaseOnlyForm(query_form))
     return false;
   std::string username = base::UTF16ToUTF8(query_form.username_value);
   std::vector<SecKeychainItemRef> matches =
       MatchingKeychainItems(query_form.signon_realm, query_form.scheme,
                             NULL, username.c_str());
-  for (std::vector<SecKeychainItemRef>::iterator i = matches.begin();
-       i != matches.end(); ++i) {
-    keychain_->Free(*i);
-  }
+  for (SecKeychainItemRef item : matches)
+    keychain_->Free(item);
 
   return !matches.empty();
 }
 
 std::vector<SecKeychainItemRef>
     MacKeychainPasswordFormAdapter::GetAllPasswordFormKeychainItems() {
   SecAuthenticationType supported_auth_types[] = {
     kSecAuthenticationTypeHTMLForm,
     kSecAuthenticationTypeHTTPBasic,
     kSecAuthenticationTypeHTTPDigest,
@@ skipping 111 matching lines @@
   // Path doesn't make sense for Android app credentials.
   if (!password_manager::IsValidAndroidFacetURI(form.signon_realm))
     path = form.origin.path();
   std::string username = base::UTF16ToUTF8(form.username_value);
   std::vector<SecKeychainItemRef> matches = MatchingKeychainItems(
       form.signon_realm, form.scheme, path.c_str(), username.c_str());
 
   if (matches.empty()) {
     return NULL;
   }
+
   // Free all items after the first, since we won't be returning them.
-  for (std::vector<SecKeychainItemRef>::iterator i = matches.begin() + 1;
-       i != matches.end(); ++i) {
+  for (auto i = matches.begin() + 1; i != matches.end(); ++i)
     keychain_->Free(*i);
-  }
+
   return matches[0];
 }
 
 std::vector<SecKeychainItemRef>
     MacKeychainPasswordFormAdapter::MatchingKeychainItems(
         const std::string& signon_realm,
         autofill::PasswordForm::Scheme scheme,
         const char* path, const char* username) {
   std::vector<SecKeychainItemRef> matches;
 
@@ skipping 37 matching lines @@
     case PasswordForm::SCHEME_OTHER:  return kSecAuthenticationTypeDefault;
     case PasswordForm::SCHEME_USERNAME_ONLY:
       NOTREACHED();
       break;
   }
   NOTREACHED();
   return kSecAuthenticationTypeDefault;
 }
 
 bool MacKeychainPasswordFormAdapter::SetKeychainItemPassword(
-    const SecKeychainItemRef& keychain_item, const std::string& password) {
+    SecKeychainItemRef keychain_item,
+    const std::string& password) {
   OSStatus result = keychain_->ItemModifyAttributesAndData(keychain_item, NULL,
                                                            password.size(),
                                                            password.c_str());
   return result == noErr;
 }
 
 bool MacKeychainPasswordFormAdapter::SetKeychainItemCreatorCode(
-    const SecKeychainItemRef& keychain_item, OSType creator_code) {
+    SecKeychainItemRef keychain_item,
+    OSType creator_code) {
   SecKeychainAttribute attr = { kSecCreatorItemAttr, sizeof(creator_code),
                                 &creator_code };
   SecKeychainAttributeList attrList = { 1, &attr };
   OSStatus result = keychain_->ItemModifyAttributesAndData(keychain_item,
                                                            &attrList, 0, NULL);
   return result == noErr;
 }
 
 OSType MacKeychainPasswordFormAdapter::CreatorCodeForSearch() {
   return finds_only_owned_ ? base::mac::CreatorCodeForApplication() : 0;
@@ skipping 69 matching lines @@
     if (best_match) {
       form->password_value = best_match->password_value;
       PasswordStoreChangeList change = login_db->UpdateLogin(*form);
       DCHECK_EQ(1u, change.size());
     } else {
       unmerged_forms_count++;
       bool removed = login_db->RemoveLogin(*form);
       DCHECK(removed);
     }
   }
-  base::STLDeleteContainerPairSecondPointers(item_form_pairs.begin(),
-                                             item_form_pairs.end());
   for (SecKeychainItemRef item : keychain_items)
     keychain->Free(item);
 
   if (unmerged_forms_count) {
     UMA_HISTOGRAM_COUNTS(
         "PasswordManager.KeychainMigration.NumPasswordsOnFailure",
         database_forms.size());
     UMA_HISTOGRAM_COUNTS("PasswordManager.KeychainMigration.NumFailedPasswords",
                          unmerged_forms_count);
     return MIGRATION_PARTIAL;
@@ skipping 370 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);
 }