Clean-up NativeBackendLibsecretTest

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 "base/basictypes.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 61 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.
-std::vector<MockSecretItem*> global_mock_libsecret_items;
+ScopedVector<MockSecretItem>* global_mock_libsecret_items;
 bool global_mock_libsecret_reject_local_ids = false;
 
-void ClearMockObjects() {
-  for (size_t i = 0; i < global_mock_libsecret_items.size(); ++i)
-    delete global_mock_libsecret_items[i];
-  global_mock_libsecret_items.clear();
-}
-
 gboolean mock_secret_password_store_sync(const SecretSchema* schema,
                                          const gchar* collection,
                                          const gchar* label,
                                          const gchar* password,
                                          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);
   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(item);
   return true;
 }
 
 GList* mock_secret_service_search_sync(SecretService* service,
                                        const SecretSchema* schema,
                                        GHashTable* attributes,
                                        SecretSearchFlags flags,
                                        GCancellable* cancellable,
                                        GError** error) {
   GList* result = nullptr;
-  for (uint32_t i = 0; i < global_mock_libsecret_items.size(); ++i) {
-    if (Matches(global_mock_libsecret_items[i], attributes))
-      result = g_list_append(result, global_mock_libsecret_items[i]);
+  for (MockSecretItem* item : *global_mock_libsecret_items) {
+    if (Matches(item, attributes))
+      result = g_list_append(result, item);
   }
   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);
-  for (uint32_t i = 0; i < global_mock_libsecret_items.size();)
-    if (Matches(global_mock_libsecret_items[i], attributes)) {
-      delete global_mock_libsecret_items[i];
-      global_mock_libsecret_items.erase(global_mock_libsecret_items.begin() +
-                                        i);
+  for (uint32_t i = 0; i < global_mock_libsecret_items->size();)
+    if (Matches((*global_mock_libsecret_items)[i], attributes)) {
+      global_mock_libsecret_items->erase(global_mock_libsecret_items->begin() +
+                                         i);
     } else {
       ++i;
     }
   g_hash_table_unref(attributes);
   return true;
 }
 
 MockSecretValue* mock_secret_item_get_secret(MockSecretItem* self) {
   return self->value;
 }
@@ skipping 30 matching lines @@
     secret_value_get_text =
         (decltype(&::secret_value_get_text)) & mock_secret_value_get_text;
     secret_item_get_attributes = (decltype(&::secret_item_get_attributes)) &
                                  mock_secret_item_get_attributes;
     secret_item_load_secret_sync = (decltype(&::secret_item_load_secret_sync)) &
                                    mock_secret_item_load_secret_sync;
     secret_value_unref =
         (decltype(&::secret_value_unref)) & mock_secret_value_unref;
     libsecret_loaded = true;
     // Reset the state of the mock library.
-    ClearMockObjects();
+    global_mock_libsecret_items->clear();
     global_mock_libsecret_reject_local_ids = false;
     return true;
   }
 };
 
 void CheckPasswordChanges(const PasswordStoreChangeList& expected_list,
                           const PasswordStoreChangeList& actual_list) {
   ASSERT_EQ(expected_list.size(), actual_list.size());
   for (size_t i = 0; i < expected_list.size(); ++i) {
     EXPECT_EQ(expected_list[i].type(), actual_list[i].type());
@@ skipping 18 matching lines @@
     EXPECT_EQ(expected.date_synced, actual.date_synced);
     EXPECT_EQ(expected.display_name, actual.display_name);
     EXPECT_EQ(expected.avatar_url, actual.avatar_url);
     EXPECT_EQ(expected.federation_url, actual.federation_url);
     EXPECT_EQ(expected.skip_zero_click, actual.skip_zero_click);
     EXPECT_EQ(expected.generation_upload_status,
               actual.generation_upload_status);
   }
 }
 
-void CheckPasswordChangesWithResult(const PasswordStoreChangeList* expected,
-                                    const PasswordStoreChangeList* actual,
-                                    bool result) {
-  EXPECT_TRUE(result);
-  CheckPasswordChanges(*expected, *actual);
-}
-
 }  // anonymous namespace
 
 class NativeBackendLibsecretTest : public testing::Test {
  protected:
   enum UpdateType {  // Used in CheckPSLUpdate().
     UPDATE_BY_UPDATELOGIN,
     UPDATE_BY_ADDLOGIN,
   };
   enum RemoveBetweenMethod {  // Used in CheckRemoveLoginsBetween().
     CREATED,
     SYNCED,
   };
 
   NativeBackendLibsecretTest() {}
 
   void SetUp() override {
+    ASSERT_FALSE(global_mock_libsecret_items);
+    global_mock_libsecret_items = &mock_libsecret_items_;
+
     ASSERT_TRUE(MockLibsecretLoader::LoadMockLibsecret());
 
     form_google_.origin = GURL("http://www.google.com/");
     form_google_.action = GURL("http://www.google.com/login");
     form_google_.username_element = UTF8ToUTF16("user");
     form_google_.username_value = UTF8ToUTF16("joeschmoe");
     form_google_.password_element = UTF8ToUTF16("pass");
     form_google_.password_value = UTF8ToUTF16("seekrit");
     form_google_.submit_element = UTF8ToUTF16("submit");
     form_google_.signon_realm = "http://www.google.com/";
@@ skipping 38 matching lines @@
     other_auth_.password_value = UTF8ToUTF16("pass");
     other_auth_.signon_realm = "http://www.example.com/Realm";
     other_auth_.date_created = base::Time::Now();
     other_auth_.date_synced = base::Time::Now();
   }
 
   void TearDown() override {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     base::MessageLoop::current()->Run();
-    ClearMockObjects();
+    ASSERT_TRUE(global_mock_libsecret_items);
+    global_mock_libsecret_items = nullptr;
   }
 
   void RunUIThread() { base::MessageLoop::current()->Run(); }
 
   void CheckUint32Attribute(const MockSecretItem* item,
                             const std::string& attribute,
                             uint32_t value) {
     gpointer item_value =
         g_hash_table_lookup(item->attributes, attribute.c_str());
     EXPECT_TRUE(item_value) << " in attribute " << attribute;
@@ skipping 69 matching lines @@
     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");
       target_form.scheme = scheme;
     }
     ScopedVector<autofill::PasswordForm> form_list;
     backend.GetLogins(target_form, &form_list);
 
-    EXPECT_EQ(1u, global_mock_libsecret_items.size());
-    if (global_mock_libsecret_items.size() > 0)
-      CheckMockSecretItem(global_mock_libsecret_items[0], credentials,
+    EXPECT_EQ(1u, global_mock_libsecret_items->size());
+    if (!global_mock_libsecret_items->empty())
+      CheckMockSecretItem((*global_mock_libsecret_items)[0], credentials,
                           "chrome-321");
-    ClearMockObjects();
+    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);
 
     backend.AddLogin(form_facebook_);
 
     // Get the PSL-matched copy of the saved login for m.facebook.
     const GURL kMobileURL("http://m.facebook.com/");
     PasswordForm m_facebook_lookup;
     m_facebook_lookup.origin = kMobileURL;
     m_facebook_lookup.signon_realm = kMobileURL.spec();
     ScopedVector<autofill::PasswordForm> form_list;
     backend.GetLogins(m_facebook_lookup, &form_list);
 
-    EXPECT_EQ(1u, global_mock_libsecret_items.size());
+    EXPECT_EQ(1u, global_mock_libsecret_items->size());
     EXPECT_EQ(1u, form_list.size());
     PasswordForm m_facebook = *form_list[0];
     form_list.clear();
     EXPECT_EQ(kMobileURL, m_facebook.origin);
     EXPECT_EQ(kMobileURL.spec(), m_facebook.signon_realm);
 
     // Add the PSL-matched copy to saved logins.
     backend.AddLogin(m_facebook);
-    EXPECT_EQ(2u, global_mock_libsecret_items.size());
+    EXPECT_EQ(2u, global_mock_libsecret_items->size());
 
     // Update www.facebook.com login.
     PasswordForm new_facebook(form_facebook_);
     const base::string16 kOldPassword(form_facebook_.password_value);
     const base::string16 kNewPassword(UTF8ToUTF16("new_b"));
     EXPECT_NE(kOldPassword, kNewPassword);
     new_facebook.password_value = kNewPassword;
     scoped_ptr<PasswordStoreChangeList> not_used(new PasswordStoreChangeList());
     switch (update_type) {
       case UPDATE_BY_UPDATELOGIN:
         backend.UpdateLogin(new_facebook, not_used.get());
         break;
       case UPDATE_BY_ADDLOGIN:
         backend.AddLogin(new_facebook);
         break;
     }
 
-    EXPECT_EQ(2u, global_mock_libsecret_items.size());
+    EXPECT_EQ(2u, global_mock_libsecret_items->size());
 
     // Check that m.facebook.com login was not modified by the update.
     backend.GetLogins(m_facebook_lookup, &form_list);
 
     // There should be two results -- the exact one, and the PSL-matched one.
     EXPECT_EQ(2u, form_list.size());
     size_t index_non_psl = 0;
     if (!form_list[index_non_psl]->original_signon_realm.empty())
       index_non_psl = 1;
     EXPECT_EQ(kMobileURL, form_list[index_non_psl]->origin);
@@ skipping 58 matching lines @@
     PasswordStoreChangeList expected_changes;
     expected_changes.push_back(
         PasswordStoreChange(PasswordStoreChange::REMOVE, form_google_));
     PasswordStoreChangeList changes;
     bool (NativeBackendLibsecret::*method)(
         base::Time, base::Time, password_manager::PasswordStoreChangeList*) =
         date_to_test == CREATED
             ? &NativeBackendLibsecret::RemoveLoginsCreatedBetween
             : &NativeBackendLibsecret::RemoveLoginsSyncedBetween;
 
-    bool result = base::Bind(method, base::Unretained(&backend), base::Time(),
-                             next_day, &changes).Run();
-    CheckPasswordChangesWithResult(&expected_changes, &changes, result);
+    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.size() > 0)
-      CheckMockSecretItem(global_mock_libsecret_items[0], form_isc_,
+    EXPECT_EQ(1u, global_mock_libsecret_items->size());
+    if (!global_mock_libsecret_items->empty() > 0)
+      CheckMockSecretItem((*global_mock_libsecret_items)[0], form_isc_,
                           "chrome-42");
 
     // Remove form_isc_.
     expected_changes.clear();
     expected_changes.push_back(
         PasswordStoreChange(PasswordStoreChange::REMOVE, form_isc_));
 
-    result = base::Bind(method, base::Unretained(&backend), next_day,
-                        base::Time(), &changes).Run();
-    CheckPasswordChangesWithResult(&expected_changes, &changes, result);
+    EXPECT_TRUE(base::Bind(method, base::Unretained(&backend), next_day,
+                           base::Time(), &changes).Run());
+    CheckPasswordChanges(expected_changes, changes);
 
-    EXPECT_EQ(0u, global_mock_libsecret_items.size());
+    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_;
 };
 
 TEST_F(NativeBackendLibsecretTest, BasicAddLogin) {
   NativeBackendLibsecret backend(42);
 
   backend.AddLogin(form_google_);
 
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, BasicListLogins) {
   NativeBackendLibsecret backend(42);
 
   backend.AddLogin(form_google_);
 
   ScopedVector<autofill::PasswordForm> form_list;
   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.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 }
 
 // Save a password for www.facebook.com and see it suggested for m.facebook.com.
 TEST_F(NativeBackendLibsecretTest, PSLMatchingPositive) {
   PasswordForm result;
   const GURL kMobileURL("http://m.facebook.com/");
   EXPECT_TRUE(CheckCredentialAvailability(form_facebook_, kMobileURL,
                                           PasswordForm::SCHEME_HTML, &result));
   EXPECT_EQ(kMobileURL, result.origin);
@@ skipping 34 matching lines @@
 
 TEST_F(NativeBackendLibsecretTest, BasicUpdateLogin) {
   NativeBackendLibsecret backend(42);
 
   backend.AddLogin(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.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 
   // Update login
   PasswordStoreChangeList changes;
   backend.UpdateLogin(new_form_google, &changes);
 
   ASSERT_EQ(1u, changes.size());
   EXPECT_EQ(PasswordStoreChange::UPDATE, changes.front().type());
   EXPECT_EQ(new_form_google, changes.front().form());
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], 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");
 }
 
 TEST_F(NativeBackendLibsecretTest, BasicRemoveLogin) {
   NativeBackendLibsecret backend(42);
 
   backend.AddLogin(form_google_);
 
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 
   backend.RemoveLogin(form_google_);
 
-  EXPECT_EQ(0u, global_mock_libsecret_items.size());
+  EXPECT_TRUE(global_mock_libsecret_items->empty());
 }
 
 // Verify fix for http://crbug.com/408783.
 TEST_F(NativeBackendLibsecretTest, RemoveLoginActionMismatch) {
   NativeBackendLibsecret backend(42);
 
   backend.AddLogin(form_google_);
 
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 
   // Action url match not required for removal.
   form_google_.action = GURL("https://some.other.url.com/path");
 
   backend.RemoveLogin(form_google_);
 
-  EXPECT_EQ(0u, global_mock_libsecret_items.size());
+  EXPECT_TRUE(global_mock_libsecret_items->empty());
 }
 
 TEST_F(NativeBackendLibsecretTest, RemoveNonexistentLogin) {
   NativeBackendLibsecret backend(42);
 
   // First add an unrelated login.
   backend.AddLogin(form_google_);
 
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 
   // Attempt to remove a login that doesn't exist.
   backend.RemoveLogin(form_isc_);
 
   // Make sure we can still get the first form back.
   ScopedVector<autofill::PasswordForm> form_list;
   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.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, UpdateNonexistentLogin) {
   NativeBackendLibsecret backend(42);
 
   // First add an unrelated login.
   backend.AddLogin(form_google_);
 
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 
   // Attempt to update a login that doesn't exist.
   PasswordStoreChangeList changes;
   backend.UpdateLogin(form_isc_, &changes);
 
   EXPECT_EQ(PasswordStoreChangeList(), changes);
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, AddDuplicateLogin) {
   NativeBackendLibsecret backend(42);
 
   PasswordStoreChangeList expected_changes, actual_changes;
   expected_changes.push_back(
       PasswordStoreChange(PasswordStoreChange::ADD, form_google_));
   actual_changes = backend.AddLogin(form_google_);
   CheckPasswordChanges(expected_changes, actual_changes);
 
   expected_changes.clear();
   expected_changes.push_back(
       PasswordStoreChange(PasswordStoreChange::REMOVE, form_google_));
   form_google_.times_used++;
   expected_changes.push_back(
       PasswordStoreChange(PasswordStoreChange::ADD, form_google_));
 
   actual_changes = backend.AddLogin(form_google_);
   CheckPasswordChanges(expected_changes, actual_changes);
 
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], form_google_,
                         "chrome-42");
 }
 
 TEST_F(NativeBackendLibsecretTest, ListLoginsAppends) {
   NativeBackendLibsecret backend(42);
 
   backend.AddLogin(form_google_);
 
   // Send the same request twice with the same list both times.
   ScopedVector<autofill::PasswordForm> form_list;
   backend.GetAutofillableLogins(&form_list);
   backend.GetAutofillableLogins(&form_list);
 
   // Quick check that we got two results back.
   EXPECT_EQ(2u, form_list.size());
   form_list.clear();
 
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
-  if (global_mock_libsecret_items.size() > 0)
-    CheckMockSecretItem(global_mock_libsecret_items[0], form_google_,
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
+  if (!global_mock_libsecret_items->empty())
+    CheckMockSecretItem((*global_mock_libsecret_items)[0], 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 =
@@ skipping 20 matching lines @@
 TEST_F(NativeBackendLibsecretTest, RemoveLoginsSyncedBetween) {
   CheckRemoveLoginsBetween(SYNCED);
 }
 
 TEST_F(NativeBackendLibsecretTest, SomeKeyringAttributesAreMissing) {
   // Absent attributes should be filled with default values.
   NativeBackendLibsecret backend(42);
 
   backend.AddLogin(form_google_);
 
-  EXPECT_EQ(1u, global_mock_libsecret_items.size());
+  EXPECT_EQ(1u, global_mock_libsecret_items->size());
   // Remove a string attribute.
-  global_mock_libsecret_items[0]->RemoveAttribute("avatar_url");
+  (*global_mock_libsecret_items)[0]->RemoveAttribute("avatar_url");
   // Remove an integer attribute.
-  global_mock_libsecret_items[0]->RemoveAttribute("ssl_valid");
+  (*global_mock_libsecret_items)[0]->RemoveAttribute("ssl_valid");
 
   ScopedVector<autofill::PasswordForm> form_list;
   backend.GetAutofillableLogins(&form_list);
 
   EXPECT_EQ(1u, form_list.size());
   EXPECT_EQ(GURL(""), form_list[0]->avatar_url);
   EXPECT_FALSE(form_list[0]->ssl_valid);
 }
 
 // TODO(mdm): add more basic tests here at some point.