Remove ScopedVector from ios/.

ios/chrome/browser/ui/settings/save_passwords_collection_view_controller.mm

 // Copyright 2015 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.
 
 #import "ios/chrome/browser/ui/settings/save_passwords_collection_view_controller.h"
 
 #include <memory>
+#include <vector>
 
 #include "base/ios/ios_util.h"
 #import "base/ios/weak_nsobject.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #import "base/mac/objc_property_releaser.h"
 #import "base/mac/scoped_nsobject.h"
-#include "base/memory/scoped_vector.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/keyed_service/core/service_access_type.h"
 #include "components/password_manager/core/browser/affiliation_utils.h"
 #include "components/password_manager/core/browser/password_manager_constants.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/browser/password_store_consumer.h"
@@ skipping 111 matching lines @@
   scoped_refptr<password_manager::PasswordStore> passwordStore_;
   // A helper object for passing data about saved passwords from a finished
   // password store request to the SavePasswordsCollectionViewController.
   std::unique_ptr<password_manager::SavePasswordsConsumer>
       savedPasswordsConsumer_;
   // A helper object for passing data about blacklisted sites from a finished
   // password store request to the SavePasswordsCollectionViewController.
   std::unique_ptr<password_manager::SavePasswordsConsumer>
       blacklistPasswordsConsumer_;
   // The list of the user's saved passwords.
-  ScopedVector<autofill::PasswordForm> savedForms_;
+  std::vector<std::unique_ptr<autofill::PasswordForm>> savedForms_;
   // The list of the user's blacklisted sites.
-  ScopedVector<autofill::PasswordForm> blacklistedForms_;
+  std::vector<std::unique_ptr<autofill::PasswordForm>> blacklistedForms_;
   // Deletion of password being asynchronous, and the method taking a reference
   // to the PasswordForm, the PasswordForm must outlive the calls to
   // RemoveLogin. This vector will ensure this.
-  ScopedVector<autofill::PasswordForm> deletedForms_;
+  std::vector<std::unique_ptr<autofill::PasswordForm>> deletedForms_;
   // The current Chrome browser state.
   ios::ChromeBrowserState* browserState_;
   // Object storing the time of the previous successful re-authentication.
   // This is meant to be used by the |ReauthenticationModule| for keeping
   // re-authentications valid for a certain time interval within the scope
   // of the Save Passwords Settings.
   base::scoped_nsobject<NSDate> successfulReauthTime_;
   // Module containing the reauthentication mechanism for viewing and copying
   // passwords.
   base::scoped_nsobject<ReauthenticationModule> reauthenticationModule_;
@@ skipping 64 matching lines @@
   // Saved passwords.
   if ([passwordManagerEnabled_ value]) {
     if (!savedForms_.empty()) {
       [model addSectionWithIdentifier:SectionIdentifierSavedPasswords];
       CollectionViewTextItem* headerItem = [[[CollectionViewTextItem alloc]
           initWithType:ItemTypeHeader] autorelease];
       headerItem.text =
           l10n_util::GetNSString(IDS_PASSWORD_MANAGER_SHOW_PASSWORDS_TAB_TITLE);
       [model setHeader:headerItem
           forSectionWithIdentifier:SectionIdentifierSavedPasswords];
-      for (size_t i = 0; i < savedForms_.size(); ++i) {
-        autofill::PasswordForm* form = savedForms_[i];
-        [model addItem:[self savedFormItemWithForm:form]
+      for (const auto& form : savedForms_) {
+        [model addItem:[self savedFormItemWithForm:form.get()]
             toSectionWithIdentifier:SectionIdentifierSavedPasswords];
       }
     }
     if (!blacklistedForms_.empty()) {
       [model addSectionWithIdentifier:SectionIdentifierBlacklist];
       CollectionViewTextItem* headerItem = [[[CollectionViewTextItem alloc]
           initWithType:ItemTypeHeader] autorelease];
       headerItem.text =
           l10n_util::GetNSString(IDS_PASSWORD_MANAGER_EXCEPTIONS_TAB_TITLE);
       [model setHeader:headerItem
           forSectionWithIdentifier:SectionIdentifierBlacklist];
-      for (size_t i = 0; i < blacklistedForms_.size(); ++i) {
-        autofill::PasswordForm* form = blacklistedForms_[i];
-        [model addItem:[self blacklistedFormItemWithForm:form]
+      for (const auto& form : blacklistedForms_) {
+        [model addItem:[self blacklistedFormItemWithForm:form.get()]
             toSectionWithIdentifier:SectionIdentifierBlacklist];
       }
     }
   }
 }
 
 #pragma mark - Items
 
 - (CollectionViewItem*)manageAccountLinkItem {
   CollectionViewFooterItem* footerItem = [[[CollectionViewFooterItem alloc]
@@ skipping 175 matching lines @@
   passwordStore_->GetAutofillableLogins(savedPasswordsConsumer_.get());
   blacklistPasswordsConsumer_.reset(
       new password_manager::SavePasswordsConsumer(self));
   passwordStore_->GetBlacklistLogins(blacklistPasswordsConsumer_.get());
 }
 
 - (void)onGetPasswordStoreResults:
     (const std::vector<std::unique_ptr<autofill::PasswordForm>>&)result {
   for (auto it = result.begin(); it != result.end(); ++it) {
     // PasswordForm is needed when user wants to delete the site/password.
-    autofill::PasswordForm* form = new autofill::PasswordForm(**it);
+    auto form = base::MakeUnique<autofill::PasswordForm>(**it);
     if (form->blacklisted_by_user)
-      blacklistedForms_.push_back(form);
+      blacklistedForms_.push_back(std::move(form));
     else
-      savedForms_.push_back(form);
+      savedForms_.push_back(std::move(form));
   }
 
   [self updateEditButton];
   [self reloadData];
 }
 
 - (BOOL)shouldShowEditButton {
   return [passwordManagerEnabled_ value];
 }
 
@@ skipping 12 matching lines @@
   if (self.editing) {
     return;
   }
 
   CollectionViewModel* model = self.collectionViewModel;
   if ([model itemTypeForIndexPath:indexPath] == ItemTypeSavedPassword) {
     DCHECK_EQ([model sectionIdentifierForSection:indexPath.section],
               SectionIdentifierSavedPasswords);
     if (experimental_flags::IsViewCopyPasswordsEnabled()) {
       DCHECK_LT(base::checked_cast<size_t>(indexPath.item), savedForms_.size());
-      autofill::PasswordForm* form = savedForms_[indexPath.item];
+      autofill::PasswordForm* form = savedForms_[indexPath.item].get();
       NSString* username = base::SysUTF16ToNSString(form->username_value);
       NSString* password = base::SysUTF16ToNSString(form->password_value);
       NSString* origin =
           base::SysUTF8ToNSString(GetHumanReadableOriginCopy(*form));
       base::scoped_nsobject<UIViewController> controller(
           [[PasswordDetailsCollectionViewController alloc]
                 initWithPasswordForm:*form
                             delegate:self
               reauthenticationModule:reauthenticationModule_
                             username:username
@@ skipping 26 matching lines @@
   int blacklistedDeleted = 0;
   for (NSIndexPath* indexPath in sortedIndexPaths) {
     // Only form items are editable.
     CollectionViewTextItem* item =
         base::mac::ObjCCastStrict<CollectionViewTextItem>(
             [self.collectionViewModel itemAtIndexPath:indexPath]);
     BOOL blacklisted = [item isKindOfClass:[BlacklistedFormContentItem class]];
     unsigned int formIndex = (unsigned int)indexPath.item;
     // Adjust index to account for deleted items.
     formIndex -= blacklisted ? blacklistedDeleted : passwordsDeleted;
-    ScopedVector<autofill::PasswordForm>& forms =
-        blacklisted ? blacklistedForms_ : savedForms_;
+    auto& forms = blacklisted ? blacklistedForms_ : savedForms_;
     DCHECK_LT(formIndex, forms.size());
     auto formIterator = forms.begin() + formIndex;
-    passwordStore_->RemoveLogin(**formIterator);
-    deletedForms_.push_back(*formIterator);
-    forms.weak_erase(formIterator);
+    std::unique_ptr<autofill::PasswordForm> form = std::move(*formIterator);
+    forms.erase(formIterator);
+    passwordStore_->RemoveLogin(*form);
+    deletedForms_.push_back(std::move(form));
     if (blacklisted) {
       ++blacklistedDeleted;
     } else {
       ++passwordsDeleted;
     }
   }
 
   // Must call super at the end of the child implementation.
   [super collectionView:collectionView willDeleteItemsAtIndexPaths:indexPaths];
 }
@@ skipping 39 matching lines @@
         [strongSelf updateEditButton];
       }];
 }
 
 #pragma mark PasswordDetailsCollectionViewControllerDelegate
 
 - (void)deletePassword:(const autofill::PasswordForm&)form {
   passwordStore_->RemoveLogin(form);
   for (auto it = savedForms_.begin(); it != savedForms_.end(); ++it) {
     if (**it == form) {
-      savedForms_.weak_erase(it);

[sdefresne, 2017/01/09 14:02:29]

IIUC, this mean that we used to leak autofill::PasswordForm when we called this
method (I agree that the new code is correct). Thank you.

[Avi (use Gerrit), 2017/01/09 15:55:11]

I was going to point this out in a comment but forgot. Yes, it seems we were
leaking here, and that's now fixed.

+      savedForms_.erase(it);
       return;
     }
   }
   [self.navigationController popViewControllerAnimated:YES];
 }
 
 #pragma mark SuccessfulReauthTimeAccessor
 
 - (void)updateSuccessfulReauthTime {
   successfulReauthTime_.reset([[NSDate alloc] init]);
 }
 
 - (NSDate*)lastSuccessfulReauthTime {
   return successfulReauthTime_.get();
 }
 
 @end