GetLoginsRequest: Use ScopedVector to express ownership of forms

chrome/browser/sync/test/integration/passwords_helper.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/sync/test/integration/passwords_helper.h"
 
 #include "base/compiler_specific.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/test/integration/multi_client_status_change_checker.h"
 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/single_client_status_change_checker.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "components/password_manager/core/browser/password_form_data.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/browser/password_store_consumer.h"
 #include "content/public/test/test_utils.h"
 
 using autofill::PasswordForm;
 using password_manager::PasswordStore;
 using sync_datatype_helper::test;
 
-const std::string kFakeSignonRealm = "http://fake-signon-realm.google.com/";
-const char* kIndexedFakeOrigin = "http://fake-signon-realm.google.com/%d";
+namespace {
 
-namespace {
+const char kFakeSignonRealm[] = "http://fake-signon-realm.google.com/";
+const char kIndexedFakeOrigin[] = "http://fake-signon-realm.google.com/%d";
 
 // We use a WaitableEvent to wait when logins are added, removed, or updated
 // instead of running the UI message loop because of a restriction that
 // prevents a DB thread from initiating a quit of the UI message loop.
 void PasswordStoreCallback(base::WaitableEvent* wait_event) {
   // Wake up passwords_helper::AddLogin.
   wait_event->Signal();
 }
 
 class PasswordStoreConsumerHelper
     : public password_manager::PasswordStoreConsumer {
  public:
-  explicit PasswordStoreConsumerHelper(std::vector<PasswordForm>* result)
-      : password_manager::PasswordStoreConsumer(), result_(result) {}
+  PasswordStoreConsumerHelper() {}
 
-  void OnGetPasswordStoreResults(
-      const std::vector<PasswordForm*>& result) override {
-    result_->clear();
-    for (std::vector<PasswordForm*>::const_iterator it = result.begin();
-         it != result.end();
-         ++it) {
-      result_->push_back(**it);
-      delete *it;
-    }
-
+  void OnGetPasswordStoreResults(ScopedVector<PasswordForm> results) override {
+    result_.swap(results);
     // Quit the message loop to wake up passwords_helper::GetLogins.
     base::MessageLoopForUI::current()->Quit();
   }
 
+  ScopedVector<PasswordForm> result() { return result_.Pass(); }
+
  private:
-  std::vector<PasswordForm>* result_;
+  ScopedVector<PasswordForm> result_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordStoreConsumerHelper);
 };
 
 // PasswordForm::date_synced is a local field. Therefore it may be different
 // across clients.
-void ClearSyncDateField(std::vector<PasswordForm>* forms) {
-  for (std::vector<PasswordForm>::iterator it = forms->begin();
-       it != forms->end();
-       ++it) {
-    it->date_synced = base::Time();
+void ClearSyncDateField(std::vector<PasswordForm*>* forms) {
+  for (PasswordForm* form : *forms) {
+    form->date_synced = base::Time();
   }
 }
 
 }  // namespace
 
 namespace passwords_helper {
 
 void AddLogin(PasswordStore* store, const PasswordForm& form) {
   ASSERT_TRUE(store);
   base::WaitableEvent wait_event(true, false);
   store->AddLogin(form);
   store->ScheduleTask(base::Bind(&PasswordStoreCallback, &wait_event));
   wait_event.Wait();
 }
 
 void UpdateLogin(PasswordStore* store, const PasswordForm& form) {
   ASSERT_TRUE(store);
   base::WaitableEvent wait_event(true, false);
   store->UpdateLogin(form);
   store->ScheduleTask(base::Bind(&PasswordStoreCallback, &wait_event));
   wait_event.Wait();
 }
 
-void GetLogins(PasswordStore* store, std::vector<PasswordForm>& matches) {
-  ASSERT_TRUE(store);
+ScopedVector<PasswordForm> GetLogins(PasswordStore* store) {
+  EXPECT_TRUE(store);
   PasswordForm matcher_form;
   matcher_form.signon_realm = kFakeSignonRealm;
-  PasswordStoreConsumerHelper consumer(&matches);
+  PasswordStoreConsumerHelper consumer;
   store->GetLogins(matcher_form, PasswordStore::DISALLOW_PROMPT, &consumer);
   content::RunMessageLoop();
+  return consumer.result();
 }
 
 void RemoveLogin(PasswordStore* store, const PasswordForm& form) {
   ASSERT_TRUE(store);
   base::WaitableEvent wait_event(true, false);
   store->RemoveLogin(form);
   store->ScheduleTask(base::Bind(&PasswordStoreCallback, &wait_event));
   wait_event.Wait();
 }
 
 void RemoveLogins(PasswordStore* store) {
-  std::vector<PasswordForm> forms;
-  GetLogins(store, forms);
-  for (std::vector<PasswordForm>::iterator it = forms.begin();
-       it != forms.end(); ++it) {
-    RemoveLogin(store, *it);
+  ScopedVector<PasswordForm> forms = GetLogins(store);
+  for (const PasswordForm* form : forms) {
+    RemoveLogin(store, *form);
   }
 }
 
 void SetEncryptionPassphrase(int index,
                              const std::string& passphrase,
                              ProfileSyncService::PassphraseType type) {
   ProfileSyncServiceFactory::GetForProfile(
       test()->GetProfile(index))->SetEncryptionPassphrase(passphrase, type);
 }
 
 bool SetDecryptionPassphrase(int index, const std::string& passphrase) {
   return ProfileSyncServiceFactory::GetForProfile(
       test()->GetProfile(index))->SetDecryptionPassphrase(passphrase);
 }
 
 PasswordStore* GetPasswordStore(int index) {
   return PasswordStoreFactory::GetForProfile(test()->GetProfile(index),
                                              ServiceAccessType::IMPLICIT_ACCESS)
       .get();
 }
 
 PasswordStore* GetVerifierPasswordStore() {
   return PasswordStoreFactory::GetForProfile(
              test()->verifier(), ServiceAccessType::IMPLICIT_ACCESS).get();
 }
 
 bool ProfileContainsSamePasswordFormsAsVerifier(int index) {
-  std::vector<PasswordForm> verifier_forms;
-  std::vector<PasswordForm> forms;
-  GetLogins(GetVerifierPasswordStore(), verifier_forms);
-  GetLogins(GetPasswordStore(index), forms);
-  ClearSyncDateField(&forms);
-  bool result =
-      password_manager::ContainsSamePasswordForms(verifier_forms, forms);
+  ScopedVector<PasswordForm> verifier_forms =
+      GetLogins(GetVerifierPasswordStore());
+  ScopedVector<PasswordForm> forms = GetLogins(GetPasswordStore(index));
+  ClearSyncDateField(&forms.get());
+  bool result = password_manager::ContainsSamePasswordFormsPtr(
+      verifier_forms.get(), forms.get());
   if (!result) {
-    LOG(ERROR) << "Password forms in Verifier Profile:";
-    for (std::vector<PasswordForm>::iterator it = verifier_forms.begin();
-         it != verifier_forms.end(); ++it) {
-      LOG(ERROR) << *it << std::endl;
+    VLOG(1) << "Password forms in Verifier Profile:";
+    for (const PasswordForm* form : verifier_forms) {
+      VLOG(1) << *form;
     }
-    LOG(ERROR) << "Password forms in Profile" << index << ":";
-    for (std::vector<PasswordForm>::iterator it = forms.begin();
-         it != forms.end(); ++it) {
-      LOG(ERROR) << *it << std::endl;
+    VLOG(1) << "Password forms in Profile" << index << ":";
+    for (const PasswordForm* form : forms) {
+      VLOG(1) << *form;
     }
   }
   return result;
 }
 
 bool ProfilesContainSamePasswordForms(int index_a, int index_b) {
-  std::vector<PasswordForm> forms_a;
-  std::vector<PasswordForm> forms_b;
-  GetLogins(GetPasswordStore(index_a), forms_a);
-  GetLogins(GetPasswordStore(index_b), forms_b);
-  ClearSyncDateField(&forms_a);
-  ClearSyncDateField(&forms_b);
-  bool result = password_manager::ContainsSamePasswordForms(forms_a, forms_b);
+  ScopedVector<PasswordForm> forms_a = GetLogins(GetPasswordStore(index_a));
+  ScopedVector<PasswordForm> forms_b = GetLogins(GetPasswordStore(index_b));
+  ClearSyncDateField(&forms_a.get());
+  ClearSyncDateField(&forms_b.get());
+  bool result = password_manager::ContainsSamePasswordFormsPtr(forms_a.get(),
+                                                               forms_b.get());
   if (!result) {
-    LOG(ERROR) << "Password forms in Profile" << index_a << ":";
-    for (std::vector<PasswordForm>::iterator it = forms_a.begin();
-         it != forms_a.end(); ++it) {
-      LOG(ERROR) << *it << std::endl;
+    VLOG(1) << "Password forms in Profile" << index_a << ":";
+    for (const PasswordForm* form : forms_a) {
+      VLOG(1) << *form;
     }
-    LOG(ERROR) << "Password forms in Profile" << index_b << ":";
-    for (std::vector<PasswordForm>::iterator it = forms_b.begin();
-         it != forms_b.end(); ++it) {
-      LOG(ERROR) << *it << std::endl;
+    VLOG(1) << "Password forms in Profile" << index_b << ":";
+    for (const PasswordForm* form : forms_b) {
+      VLOG(1) << *form;
     }
   }
   return result;
 }
 
 bool AllProfilesContainSamePasswordFormsAsVerifier() {
   for (int i = 0; i < test()->num_clients(); ++i) {
     if (!ProfileContainsSamePasswordFormsAsVerifier(i)) {
       DVLOG(1) << "Profile " << i << " does not contain the same password"
                                      " forms as the verifier.";
@@ skipping 140 matching lines @@
 
 }  //  namespace
 
 bool AwaitProfileContainsSamePasswordFormsAsVerifier(int index) {
   SamePasswordFormsAsVerifierChecker checker(index);
   checker.Wait();
   return !checker.TimedOut();
 }
 
 int GetPasswordCount(int index) {
-  std::vector<PasswordForm> forms;
-  GetLogins(GetPasswordStore(index), forms);
+  ScopedVector<PasswordForm> forms = GetLogins(GetPasswordStore(index));
   return forms.size();
 }
 
 int GetVerifierPasswordCount() {
-  std::vector<PasswordForm> verifier_forms;
-  GetLogins(GetVerifierPasswordStore(), verifier_forms);
+  ScopedVector<PasswordForm> verifier_forms =
+      GetLogins(GetVerifierPasswordStore());
   return verifier_forms.size();
 }
 
 PasswordForm CreateTestPasswordForm(int index) {
   PasswordForm form;
   form.signon_realm = kFakeSignonRealm;
   form.origin = GURL(base::StringPrintf(kIndexedFakeOrigin, index));
   form.username_value =
       base::ASCIIToUTF16(base::StringPrintf("username%d", index));
   form.password_value =
       base::ASCIIToUTF16(base::StringPrintf("password%d", index));
   form.date_created = base::Time::Now();
   return form;
 }
 
 }  // namespace passwords_helper