Remove ScopedVector from PasswordStoreX

chrome/browser/password_manager/native_backend_libsecret_unittest.cc

 // Copyright (c) 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.
 
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/location.h"
 #include "base/run_loop.h"
@@ skipping 29 matching lines @@
 // MockLibsecretLoader, which hooks into the facility normally used to load
 // the libsecret library at runtime to avoid a static dependency on it.
 
 struct MockSecretValue {
   gchar* password;
   explicit MockSecretValue(gchar* password) : password(password) {}
   ~MockSecretValue() { g_free(password); }
 };
 
 struct MockSecretItem {
-  MockSecretValue* value;
+  std::unique_ptr<MockSecretValue> value;
   GHashTable* attributes;
 
-  MockSecretItem(MockSecretValue* value, GHashTable* attributes)
-      : value(value), attributes(attributes) {}
+  MockSecretItem(std::unique_ptr<MockSecretValue> value, GHashTable* attributes)
+      : value(std::move(value)), attributes(attributes) {}
   ~MockSecretItem() {
-    delete value;
     g_hash_table_destroy(attributes);
   }
 
   void RemoveAttribute(const char* keyname) {
     g_hash_table_remove(attributes, keyname);
   }
 };
 
 bool Matches(MockSecretItem* item, GHashTable* query) {
   GHashTable* attributes = item->attributes;
@@ skipping 13 matching lines @@
 
 bool IsStringAttribute(const SecretSchema* schema, const std::string& name) {
   for (size_t i = 0; schema->attributes[i].name; ++i)
     if (name == schema->attributes[i].name)
       return schema->attributes[i].type == SECRET_SCHEMA_ATTRIBUTE_STRING;
   NOTREACHED() << "Requested type of nonexistent attribute";
   return false;
 }
 
 // The list of all libsecret items we have stored.
-ScopedVector<MockSecretItem>* global_mock_libsecret_items;
+std::vector<std::unique_ptr<MockSecretItem>>* global_mock_libsecret_items;
 bool global_mock_libsecret_reject_local_ids = false;
 
 gboolean mock_secret_password_store_sync(const SecretSchema* schema,
                                          const gchar* collection,
                                          const gchar* label,
                                          const gchar* password,
                                          GCancellable* cancellable,
                                          GError** error,
                                          ...) {
   // TODO(crbug.com/660005) We don't read the dummy we store to unlock keyring.
@@ skipping 12 matching lines @@
       VLOG(1) << "Adding item attribute " << name << ", value '" << value
               << "'";
     } else {
       uint32_t intvalue = va_arg(ap, uint32_t);
       VLOG(1) << "Adding item attribute " << name << ", value " << intvalue;
       value = g_strdup_printf("%u", intvalue);
     }
     g_hash_table_insert(attributes, g_strdup(name), value);
   }
   va_end(ap);
-  MockSecretValue* secret_value = new MockSecretValue(g_strdup(password));
-  MockSecretItem* item = new MockSecretItem(secret_value, attributes);
-  global_mock_libsecret_items->push_back(item);
+  global_mock_libsecret_items->push_back(base::MakeUnique<MockSecretItem>(
+      base::MakeUnique<MockSecretValue>(g_strdup(password)), attributes));
   return true;
 }
 
 GList* mock_secret_service_search_sync(SecretService* service,
                                        const SecretSchema* schema,
                                        GHashTable* attributes,
                                        SecretSearchFlags flags,
                                        GCancellable* cancellable,
                                        GError** error) {
   EXPECT_TRUE(flags & SECRET_SEARCH_UNLOCK);
   GList* result = nullptr;
-  for (MockSecretItem* item : *global_mock_libsecret_items) {
-    if (Matches(item, attributes))
-      result = g_list_append(result, item);
+  for (std::unique_ptr<MockSecretItem>& item : *global_mock_libsecret_items) {
+    if (Matches(item.get(), attributes))
+      result = g_list_append(result, item.get());
   }
   return result;
 }
 
 gboolean mock_secret_password_clear_sync(const SecretSchema* schema,
                                          GCancellable* cancellable,
                                          GError** error,
                                          ...) {
   GHashTable* attributes =
       g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
   va_list ap;
   va_start(ap, error);
   char* name;
   while ((name = va_arg(ap, gchar*))) {
     char* value;
     if (IsStringAttribute(schema, name)) {
       value = g_strdup(va_arg(ap, gchar*));
       VLOG(1) << "Adding item attribute " << name << ", value '" << value
               << "'";
     } else {
       uint32_t intvalue = va_arg(ap, uint32_t);
       VLOG(1) << "Adding item attribute " << name << ", value " << intvalue;
       value = g_strdup_printf("%u", intvalue);
     }
     g_hash_table_insert(attributes, g_strdup(name), value);
   }
   va_end(ap);
 
-  ScopedVector<MockSecretItem> kept_mock_libsecret_items;
+  std::vector<std::unique_ptr<MockSecretItem>> kept_mock_libsecret_items;
   kept_mock_libsecret_items.reserve(global_mock_libsecret_items->size());
-  for (auto*& item : *global_mock_libsecret_items) {
-    if (!Matches(item, attributes)) {
-      kept_mock_libsecret_items.push_back(item);
-      item = nullptr;
+  for (std::unique_ptr<MockSecretItem>& item : *global_mock_libsecret_items) {
+    if (!Matches(item.get(), attributes)) {
+      kept_mock_libsecret_items.push_back(std::move(item));
     }
   }
   global_mock_libsecret_items->swap(kept_mock_libsecret_items);
 
   g_hash_table_unref(attributes);
   return
       global_mock_libsecret_items->size() != kept_mock_libsecret_items.size();
 }
 
 SecretValue* mock_secret_item_get_secret(SecretItem* self) {
-  MockSecretValue* mock_value = reinterpret_cast<MockSecretItem*>(self)->value;
+  MockSecretValue* mock_value =
+      reinterpret_cast<MockSecretItem*>(self)->value.get();
   return reinterpret_cast<SecretValue*>(mock_value);
 }
 
 const gchar* mock_secret_value_get_text(SecretValue* value) {
   return reinterpret_cast<MockSecretValue*>(value)->password;
 }
 
 GHashTable* mock_secret_item_get_attributes(SecretItem* self) {
   // Libsecret backend will make unreference of received attributes, so in
   // order to save them we need to increase their reference number.
@@ skipping 235 matching lines @@
     VerifiedAdd(&backend, credentials);
 
     PasswordStore::FormDigest target_form = {PasswordForm::SCHEME_HTML,
                                              url.spec(), url};
     if (scheme != PasswordForm::SCHEME_HTML) {
       // For non-HTML forms, the realm used for authentication
       // (http://tools.ietf.org/html/rfc1945#section-10.2) is appended to the
       // signon_realm. Just use a default value for now.
       target_form.signon_realm.append("Realm");
     }
-    ScopedVector<autofill::PasswordForm> form_list;
+    std::vector<std::unique_ptr<PasswordForm>> form_list;
     EXPECT_TRUE(backend.GetLogins(target_form, &form_list));
 
     EXPECT_EQ(1u, global_mock_libsecret_items->size());
     if (!global_mock_libsecret_items->empty())
-      CheckMockSecretItem((*global_mock_libsecret_items)[0], credentials,
+      CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), credentials,
                           "chrome-321");
     global_mock_libsecret_items->clear();
 
     if (form_list.empty())
       return false;
     EXPECT_EQ(1u, form_list.size());
     if (result)
       *result = *form_list[0];
     return true;
   }
 
   // Test that updating does not use PSL matching: Add a www.facebook.com
   // password, then use PSL matching to get a copy of it for m.facebook.com, and
   // add that copy as well. Now update the www.facebook.com password -- the
   // m.facebook.com password should not get updated. Depending on the argument,
   // the credential update is done via UpdateLogin or AddLogin.
   void CheckPSLUpdate(UpdateType update_type) {
     NativeBackendLibsecret backend(321);
 
     VerifiedAdd(&backend, form_facebook_);
 
     // Get the PSL-matched copy of the saved login for m.facebook.
     const GURL kMobileURL("http://m.facebook.com/");
     PasswordStore::FormDigest m_facebook_lookup = {
         PasswordForm::SCHEME_HTML, kMobileURL.spec(), kMobileURL};
-    ScopedVector<autofill::PasswordForm> form_list;
+    std::vector<std::unique_ptr<PasswordForm>> form_list;
     EXPECT_TRUE(backend.GetLogins(m_facebook_lookup, &form_list));
 
     EXPECT_EQ(1u, global_mock_libsecret_items->size());
     EXPECT_EQ(1u, form_list.size());
     PasswordForm m_facebook = *form_list[0];
     form_list.clear();
     m_facebook.origin = kMobileURL;
     m_facebook.signon_realm = kMobileURL.spec();
 
     // Add the PSL-matched copy to saved logins.
@@ skipping 95 matching lines @@
         date_to_test == CREATED
             ? &NativeBackendLibsecret::RemoveLoginsCreatedBetween
             : &NativeBackendLibsecret::RemoveLoginsSyncedBetween;
 
     EXPECT_TRUE(base::Bind(method, base::Unretained(&backend), base::Time(),
                            next_day, &changes).Run());
     CheckPasswordChanges(expected_changes, changes);
 
     EXPECT_EQ(1u, global_mock_libsecret_items->size());
     if (!global_mock_libsecret_items->empty() > 0)
-      CheckMockSecretItem((*global_mock_libsecret_items)[0], form_isc_,
+      CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_isc_,
                           "chrome-42");
 
     // Remove form_isc_.
     expected_changes.clear();
     expected_changes.push_back(
         PasswordStoreChange(PasswordStoreChange::REMOVE, form_isc_));
 
     EXPECT_TRUE(base::Bind(method, base::Unretained(&backend), next_day,
                            base::Time(), &changes).Run());
     CheckPasswordChanges(expected_changes, changes);
 
     EXPECT_TRUE(global_mock_libsecret_items->empty());
   }
 
   base::MessageLoopForUI message_loop_;
 
   // Provide some test forms to avoid having to set them up in each test.
   PasswordForm form_google_;
   PasswordForm form_facebook_;
   PasswordForm form_isc_;
   PasswordForm other_auth_;
 
-  ScopedVector<MockSecretItem> mock_libsecret_items_;
+  std::vector<std::unique_ptr<MockSecretItem>> mock_libsecret_items_;
 };
 
 TEST_F(NativeBackendLibsecretTest, BasicAddLogin) {
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, BasicListLogins) {
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
 
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   EXPECT_TRUE(backend.GetAutofillableLogins(&form_list));
 
   ASSERT_EQ(1u, form_list.size());
   EXPECT_EQ(form_google_, *form_list[0]);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, GetAllLogins) {
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
   VerifiedAdd(&backend, form_facebook_);
 
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   EXPECT_TRUE(backend.GetAllLogins(&form_list));
 
   ASSERT_EQ(2u, form_list.size());
   EXPECT_THAT(form_list, UnorderedElementsAre(Pointee(form_google_),
                                               Pointee(form_facebook_)));
 }
 
 // Save a password for www.facebook.com and see it suggested for m.facebook.com.
 TEST_F(NativeBackendLibsecretTest, PSLMatchingPositive) {
   PasswordForm result;
@@ skipping 48 matching lines @@
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
 
   PasswordForm new_form_google(form_google_);
   new_form_google.times_used = 1;
   new_form_google.action = GURL("http://www.google.com/different/login");
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty()) {
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
   }
 
   // Update login
   VerifiedUpdate(&backend, new_form_google);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], new_form_google,
-                        "chrome-42");
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(),
+                        new_form_google, "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, BasicRemoveLogin) {
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
 
   VerifiedRemove(&backend, form_google_);
 
   EXPECT_TRUE(global_mock_libsecret_items->empty());
 }
 
 // Verify fix for http://crbug.com/408783.
 TEST_F(NativeBackendLibsecretTest, RemoveLoginActionMismatch) {
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
 
   // Action url match not required for removal.
   form_google_.action = GURL("https://some.other.url.com/path");
   VerifiedRemove(&backend, form_google_);
 
   EXPECT_TRUE(global_mock_libsecret_items->empty());
 }
 
 TEST_F(NativeBackendLibsecretTest, RemoveNonexistentLogin) {
   NativeBackendLibsecret backend(42);
 
   // First add an unrelated login.
   VerifiedAdd(&backend, form_google_);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
 
   // Attempt to remove a login that doesn't exist.
   PasswordStoreChangeList changes;
   EXPECT_TRUE(backend.RemoveLogin(form_isc_, &changes));
   CheckPasswordChanges(PasswordStoreChangeList(), changes);
 
   // Make sure we can still get the first form back.
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   EXPECT_TRUE(backend.GetAutofillableLogins(&form_list));
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
   form_list.clear();
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, UpdateNonexistentLogin) {
   NativeBackendLibsecret backend(42);
 
   // First add an unrelated login.
   VerifiedAdd(&backend, form_google_);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty()) {
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
   }
 
   // Attempt to update a login that doesn't exist.
   PasswordStoreChangeList changes;
   EXPECT_TRUE(backend.UpdateLogin(form_isc_, &changes));
   CheckPasswordChanges(PasswordStoreChangeList(), changes);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, UpdateSameLogin) {
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty()) {
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
   }
 
   // Attempt to update the same login without changing anything.
   PasswordStoreChangeList changes;
   EXPECT_TRUE(backend.UpdateLogin(form_google_, &changes));
   CheckPasswordChanges(PasswordStoreChangeList(), changes);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty()) {
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
   }
 }
 
 TEST_F(NativeBackendLibsecretTest, AddDuplicateLogin) {
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
 
   PasswordStoreChangeList expected_changes;
   expected_changes.push_back(
       PasswordStoreChange(PasswordStoreChange::REMOVE, form_google_));
   form_google_.times_used++;
   form_google_.submit_element = UTF8ToUTF16("submit2");
   expected_changes.push_back(
       PasswordStoreChange(PasswordStoreChange::ADD, form_google_));
 
   PasswordStoreChangeList actual_changes = backend.AddLogin(form_google_);
   CheckPasswordChanges(expected_changes, actual_changes);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty())
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, AndroidCredentials) {
   NativeBackendLibsecret backend(42);
   backend.Init();
 
   PasswordForm observed_android_form;
   observed_android_form.scheme = PasswordForm::SCHEME_HTML;
   observed_android_form.signon_realm =
       "android://7x7IDboo8u9YKraUsbmVkuf1-@net.rateflix.app/";
   PasswordForm saved_android_form = observed_android_form;
   saved_android_form.username_value = base::UTF8ToUTF16("randomusername");
   saved_android_form.password_value = base::UTF8ToUTF16("password");
   saved_android_form.date_created = base::Time::Now();
 
   VerifiedAdd(&backend, saved_android_form);
 
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   EXPECT_TRUE(backend.GetAutofillableLogins(&form_list));
 
   EXPECT_EQ(1u, form_list.size());
   EXPECT_EQ(saved_android_form, *form_list[0]);
 }
 
 TEST_F(NativeBackendLibsecretTest, RemoveLoginsCreatedBetween) {
   CheckRemoveLoginsBetween(CREATED);
 }
 
 TEST_F(NativeBackendLibsecretTest, RemoveLoginsSyncedBetween) {
   CheckRemoveLoginsBetween(SYNCED);
 }
 
 TEST_F(NativeBackendLibsecretTest, DisableAutoSignInForOrigins) {
   NativeBackendLibsecret backend(42);
   backend.Init();
   form_google_.skip_zero_click = false;
   form_facebook_.skip_zero_click = false;
 
   VerifiedAdd(&backend, form_google_);
   VerifiedAdd(&backend, form_facebook_);
 
   EXPECT_EQ(2u, global_mock_libsecret_items->size());
-  for (auto* item : *global_mock_libsecret_items)
-    CheckUint32Attribute(item, "should_skip_zero_click", 0);
+  for (const auto& item : *global_mock_libsecret_items)
+    CheckUint32Attribute(item.get(), "should_skip_zero_click", 0);
 
   // Set the canonical forms to the updated value for the following comparison.
   form_google_.skip_zero_click = true;
   form_facebook_.skip_zero_click = true;
   PasswordStoreChangeList expected_changes;
   expected_changes.push_back(
       PasswordStoreChange(PasswordStoreChange::UPDATE, form_facebook_));
 
   PasswordStoreChangeList changes;
   EXPECT_TRUE(backend.DisableAutoSignInForOrigins(
       base::Bind(static_cast<bool (*)(const GURL&, const GURL&)>(operator==),
                  form_facebook_.origin),
       &changes));
   CheckPasswordChanges(expected_changes, changes);
 
   EXPECT_EQ(2u, global_mock_libsecret_items->size());
-  CheckStringAttribute((*global_mock_libsecret_items)[0],
-                       "origin_url", form_google_.origin.spec());
-  CheckUint32Attribute((*global_mock_libsecret_items)[0],
+  CheckStringAttribute((*global_mock_libsecret_items)[0].get(), "origin_url",
+                       form_google_.origin.spec());
+  CheckUint32Attribute((*global_mock_libsecret_items)[0].get(),
                        "should_skip_zero_click", 0);
-  CheckStringAttribute((*global_mock_libsecret_items)[1],
-                       "origin_url", form_facebook_.origin.spec());
-  CheckUint32Attribute((*global_mock_libsecret_items)[1],
+  CheckStringAttribute((*global_mock_libsecret_items)[1].get(), "origin_url",
+                       form_facebook_.origin.spec());
+  CheckUint32Attribute((*global_mock_libsecret_items)[1].get(),
                        "should_skip_zero_click", 1);
 }
 
 TEST_F(NativeBackendLibsecretTest, SomeKeyringAttributesAreMissing) {
   // Absent attributes should be filled with default values.
   NativeBackendLibsecret backend(42);
 
   VerifiedAdd(&backend, form_google_);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   // Remove a string attribute.
   (*global_mock_libsecret_items)[0]->RemoveAttribute("avatar_url");
   // Remove an integer attribute.
   (*global_mock_libsecret_items)[0]->RemoveAttribute("times_used");
 
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   EXPECT_TRUE(backend.GetAutofillableLogins(&form_list));
 
   EXPECT_EQ(1u, form_list.size());
   EXPECT_EQ(GURL(""), form_list[0]->icon_url);
   EXPECT_EQ(0, form_list[0]->times_used);
 }
 
 TEST_F(NativeBackendLibsecretTest, ReadDuplicateForms) {
   NativeBackendLibsecret backend(42);
 
@@ skipping 12 matching lines @@
   ASSERT_EQ(2u, global_mock_libsecret_items->size());
   gpointer item_value = g_hash_table_lookup(
       global_mock_libsecret_items->front()->attributes, "origin_url");
   ASSERT_TRUE(item_value);
   char* substr = strstr(static_cast<char*>(item_value), unique_string);
   ASSERT_TRUE(substr);
   ASSERT_EQ(strlen(unique_string), strlen(unique_string_replacement));
   strncpy(substr, unique_string_replacement, strlen(unique_string));
 
   // Now test that GetAutofillableLogins returns only one form.
-  ScopedVector<autofill::PasswordForm> form_list;
+  std::vector<std::unique_ptr<PasswordForm>> form_list;
   EXPECT_TRUE(backend.GetAutofillableLogins(&form_list));
 
   EXPECT_EQ(1u, form_list.size());
   EXPECT_EQ(form_google_, *form_list[0]);
 
   EXPECT_EQ(1u, global_mock_libsecret_items->size());
   if (!global_mock_libsecret_items->empty()) {
-    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
+    CheckMockSecretItem((*global_mock_libsecret_items)[0].get(), form_google_,
                         "chrome-42");
   }
 }
 
 // TODO(mdm): add more basic tests here at some point.