PasswordStore: Use ScopedVector to express ownership of forms

chrome/browser/password_manager/password_store_mac_internal.h

 // 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.
 
 #ifndef CHROME_BROWSER_PASSWORD_MANAGER_PASSWORD_STORE_MAC_INTERNAL_H_
 #define CHROME_BROWSER_PASSWORD_MANAGER_PASSWORD_STORE_MAC_INTERNAL_H_
 
 #include <Security/Security.h>
 
 #include <string>
 #include <vector>
 
+#include "base/memory/scoped_vector.h"
 #include "components/autofill/core/common/password_form.h"
 #include "crypto/apple_keychain.h"
 
 using crypto::AppleKeychain;
 
 // Adapter that wraps a AppleKeychain and provides interaction in terms of
 // PasswordForms instead of Keychain items.
 class MacKeychainPasswordFormAdapter {
  public:
   // Creates an adapter for |keychain|. This class does not take ownership of
   // |keychain|, so the caller must make sure that the keychain outlives the
   // created object.
   explicit MacKeychainPasswordFormAdapter(const AppleKeychain* keychain);
 
-  // Returns PasswordForms for each keychain entry that could be used to fill
-  // |form|. Caller is responsible for deleting the returned forms.
-  std::vector<autofill::PasswordForm*> PasswordsFillingForm(
-      const std::string& signon_realm,
-      autofill::PasswordForm::Scheme scheme);
+  // Appends to |forms| all keychain entries matching |signon_realm| and
+  // |scheme|.
+  void PasswordsFillingForm(const std::string& signon_realm,
+                            autofill::PasswordForm::Scheme scheme,
+                            ScopedVector<autofill::PasswordForm>* forms);
 
   // Returns true if there is the Keychain entry that matches |query_form| on
   // all of the fields that uniquely identify a Keychain item.
   bool HasPasswordExactlyMatchingForm(const autofill::PasswordForm& query_form);
 
   // Returns true if the keychain contains any items that are mergeable with
   // |query_form|. This is different from actually extracting the passwords
   // and checking the return count, since doing that would require reading the
   // passwords from the keychain, thus potentially triggering authorizaiton UI,
   // whereas this won't.
   bool HasPasswordsMergeableWithForm(
       const autofill::PasswordForm& query_form);
 
   // Returns all keychain items of types corresponding to password forms.
   std::vector<SecKeychainItemRef> GetAllPasswordFormKeychainItems();
 
-  // Returns password data from all keychain items of types corresponding to
-  // password forms. Caller is responsible for deleting the returned forms.
-  std::vector<autofill::PasswordForm*> GetAllPasswordFormPasswords();
+  // Appends to |forms| all keychain entries corresponding to password forms.
+  void GetAllPasswordFormPasswords(ScopedVector<autofill::PasswordForm>* forms);
 
   // Creates a new keychain entry from |form|, or updates the password of an
   // existing keychain entry if there is a collision. Returns true if a keychain
   // entry was successfully added/updated.
   bool AddPassword(const autofill::PasswordForm& form);
 
   // Removes the keychain password matching |form| if any. Returns true if a
   // keychain item was found and successfully removed.
   bool RemovePassword(const autofill::PasswordForm& form);
 
   // Controls whether or not Chrome will restrict Keychain searches to items
   // that it created. Defaults to false.
   void SetFindsOnlyOwnedItems(bool finds_only_owned);
 
  private:
-  // Returns PasswordForms constructed from the given Keychain items, calling
-  // AppleKeychain::Free on all of the keychain items and clearing the vector.
-  // Caller is responsible for deleting the returned forms.
-  std::vector<autofill::PasswordForm*> ConvertKeychainItemsToForms(
-      std::vector<SecKeychainItemRef>* items);
+  // Transforms |items| to PasswordForm instances and appends them to |forms|.
+  // Also calls AppleKeychain::Free on all of the keychain items and clears
+  // |items|.
+  void ConvertKeychainItemsToForms(std::vector<SecKeychainItemRef>* items,
+                                   ScopedVector<autofill::PasswordForm>* forms);
 
   // Searches |keychain| for the specific keychain entry that corresponds to the
   // given form, and returns it (or NULL if no match is found). The caller is
   // responsible for calling AppleKeychain::Free on on the returned item.
   SecKeychainItemRef KeychainItemForForm(
       const autofill::PasswordForm& form);
 
   // Returns the Keychain items matching the given signon_realm, scheme, and
   // optionally path and username (either of both can be NULL).
   // The caller is responsible for calling AppleKeychain::Free on the
@@ skipping 77 matching lines @@
 
 // Populates merged_forms by combining the password data from keychain_forms and
 // the metadata from database_forms, removing used entries from the two source
 // lists.
 //
 // On return, database_forms and keychain_forms will have only unused
 // entries; for database_forms that means entries for which no corresponding
 // password can be found (and which aren't blacklist entries), and for
 // keychain_forms its entries that weren't merged into at least one database
 // form.
-void MergePasswordForms(
-    std::vector<autofill::PasswordForm*>* keychain_forms,
-    std::vector<autofill::PasswordForm*>* database_forms,
-    std::vector<autofill::PasswordForm*>* merged_forms);
+void MergePasswordForms(ScopedVector<autofill::PasswordForm>* keychain_forms,
+                        ScopedVector<autofill::PasswordForm>* database_forms,
+                        ScopedVector<autofill::PasswordForm>* merged_forms);
 
-// Fills in the passwords for as many of the forms in |database_forms| as
-// possible using entries from |keychain| and returns them. On return,
-// |database_forms| will contain only the forms for which no password was found.
-std::vector<autofill::PasswordForm*> GetPasswordsForForms(
-    const AppleKeychain& keychain,
-    std::vector<autofill::PasswordForm*>* database_forms);
+// For every form in |database_forms|, if such a form has a corresponding entry
+// in |keychain|, this adds the password from the entry and moves that form from
+// |database_forms| into |passwords|.
+void GetPasswordsForForms(const AppleKeychain& keychain,
+                          ScopedVector<autofill::PasswordForm>* database_forms,
+                          ScopedVector<autofill::PasswordForm>* passwords);
 
 // Loads all items in the system keychain into |keychain_items|, creates for
 // each keychain item a corresponding PasswordForm that doesn't contain any
 // password data, and returns the two collections as a vector of ItemFormPairs.
 // Used by GetPasswordsForForms for optimized matching of keychain items with
 // PasswordForms in the database.
 // Note: Since no password data is loaded here, the resulting PasswordForms
 // will include blacklist entries, which will have to be filtered out later.
 // Caller owns the SecKeychainItemRefs and PasswordForms that are returned.
 // This operation does not require OS authorization.
@@ skipping 10 matching lines @@
                                   std::string* server,
                                   UInt32* port,
                                   bool* is_secure,
                                   std::string* security_domain);
 
 // Returns true if the signon_realm of |query_form| can be successfully parsed
 // by ExtractSignonRealmComponents, and if |query_form| matches |other_form|.
 bool FormIsValidAndMatchesOtherForm(const autofill::PasswordForm& query_form,
                                     const autofill::PasswordForm& other_form);
 
-// Returns PasswordForms populated with password data for each keychain entry
-// in |item_form_pairs| that could be merged with |query_form|.
-// Caller is responsible for deleting the returned forms.
-std::vector<autofill::PasswordForm*> ExtractPasswordsMergeableWithForm(
+// Appends, to |matches|, PasswordForm instances populated with password data
+// for each keychain entry in |item_form_pairs| that could be merged with
+// |query_form|.
+void ExtractPasswordsMergeableWithForm(
     const AppleKeychain& keychain,
     const std::vector<ItemFormPair>& item_form_pairs,
-    const autofill::PasswordForm& query_form);
+    const autofill::PasswordForm& query_form,
+    ScopedVector<autofill::PasswordForm>* matches);
 
 }  // namespace internal_keychain_helpers
 
 #endif  // CHROME_BROWSER_PASSWORD_MANAGER_PASSWORD_STORE_MAC_INTERNAL_H_