PasswordStore: Use ScopedVector to express ownership of forms

chrome/browser/password_manager/native_backend_gnome_x.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/password_manager/native_backend_gnome_x.h"
 
 #include <dlfcn.h>
 #include <gnome-keyring.h>
 
 #include <map>
@@ skipping 129 matching lines @@
   base::StringToInt64(string_attr_map["date_synced"], &date_synced);
   form->date_synced = base::Time::FromInternalValue(date_synced);
   form->display_name = UTF8ToUTF16(string_attr_map["display_name"]);
   form->avatar_url = GURL(string_attr_map["avatar_url"]);
   form->federation_url = GURL(string_attr_map["federation_url"]);
   form->is_zero_click = uint_attr_map["is_zero_click"];
 
   return form.Pass();
 }
 
-// Parse all the results from the given GList into a PasswordFormList, and free
-// the GList. PasswordForms are allocated on the heap, and should be deleted by
-// the consumer. If not NULL, |lookup_form| is used to filter out results --
-// only credentials with signon realms passing the PSL matching against
-// |lookup_form->signon_realm| will be kept. PSL matched results get their
-// signon_realm, origin, and action rewritten to those of |lookup_form_|, with
-// the original signon_realm saved into the result's original_signon_realm data
-// member.
+// Parse all the results from the given GList into a
+// ScopedVector<autofill::PasswordForm>, and free the GList. PasswordForms are
+// allocated on the heap, and should be deleted by the consumer. If not NULL,
+// |lookup_form| is used to filter out results -- only credentials with signon
+// realms passing the PSL matching against |lookup_form->signon_realm| will be
+// kept. PSL matched results get their signon_realm, origin, and action
+// rewritten to those of |lookup_form_|, with the original signon_realm saved
+// into the result's original_signon_realm data member.
 void ConvertFormList(GList* found,
                      const PasswordForm* lookup_form,
-                     NativeBackendGnome::PasswordFormList* forms) {
+                     ScopedVector<autofill::PasswordForm>* forms) {
   password_manager::PSLDomainMatchMetric psl_domain_match_metric =
       password_manager::PSL_DOMAIN_MATCH_NONE;
   for (GList* element = g_list_first(found); element != NULL;
        element = g_list_next(element)) {
     GnomeKeyringFound* data = static_cast<GnomeKeyringFound*>(element->data);
     GnomeKeyringAttributeList* attrs = data->attributes;
 
     scoped_ptr<PasswordForm> form(FormFromAttributes(attrs));
     if (form) {
       if (lookup_form && form->signon_realm != lookup_form->signon_realm) {
@@ skipping 77 matching lines @@
 // PasswordStore expects of us. (It will then in turn switch back to the
 // original caller to send the asynchronous reply to the original request.)
 
 // This class represents a call to a GNOME Keyring method. A RunnableMethod
 // should be posted to the UI thread to call one of its action methods, and then
 // a WaitResult() method should be called to wait for the result. Each instance
 // supports only one outstanding method at a time, though multiple instances may
 // be used in parallel.
 class GKRMethod : public GnomeKeyringLoader {
  public:
-  typedef NativeBackendGnome::PasswordFormList PasswordFormList;
-
   GKRMethod() : event_(false, false), result_(GNOME_KEYRING_RESULT_CANCELLED) {}
 
   // Action methods. These call gnome_keyring_* functions. Call from UI thread.
   // See GetProfileSpecificAppString() for more information on the app string.
   void AddLogin(const PasswordForm& form, const char* app_string);
   void AddLoginSearch(const PasswordForm& form, const char* app_string);
   void UpdateLoginSearch(const PasswordForm& form, const char* app_string);
   void RemoveLogin(const PasswordForm& form, const char* app_string);
   void GetLogins(const PasswordForm& form, const char* app_string);
   void GetLoginsList(uint32_t blacklisted_by_user, const char* app_string);
   void GetAllLogins(const char* app_string);
 
   // Use after AddLogin, RemoveLogin.
   GnomeKeyringResult WaitResult();
 
   // Use after AddLoginSearch, UpdateLoginSearch, GetLogins, GetLoginsList,
   // GetAllLogins.
-  GnomeKeyringResult WaitResult(PasswordFormList* forms);
+  GnomeKeyringResult WaitResult(ScopedVector<autofill::PasswordForm>* forms);
 
  private:
   struct GnomeKeyringAttributeListFreeDeleter {
     inline void operator()(void* list) const {
       gnome_keyring_attribute_list_free(
           static_cast<GnomeKeyringAttributeList*>(list));
     }
   };
 
   typedef scoped_ptr<GnomeKeyringAttributeList,
@@ skipping 11 matching lines @@
                            guint32 value);
 
   // All these callbacks are called on UI thread.
   static void OnOperationDone(GnomeKeyringResult result, gpointer data);
 
   static void OnOperationGetList(GnomeKeyringResult result, GList* list,
                                  gpointer data);
 
   base::WaitableEvent event_;
   GnomeKeyringResult result_;
-  NativeBackendGnome::PasswordFormList forms_;
+  ScopedVector<autofill::PasswordForm> forms_;
   // If the credential search is specified by a single form and needs to use PSL
   // matching, then the specifying form is stored in |lookup_form_|. If PSL
   // matching is used to find a result, then the results signon realm, origin
   // and action are stored are replaced by those of |lookup_form_|.
   // Additionally, |lookup_form_->signon_realm| is also used to narrow down the
   // found logins to those which indeed PSL-match the look-up. And finally,
   // |lookup_form_| set to NULL means that PSL matching is not required.
   scoped_ptr<PasswordForm> lookup_form_;
 };
 
@@ skipping 139 matching lines @@
                            /*data=*/this,
                            /*destroy_data=*/NULL);
 }
 
 GnomeKeyringResult GKRMethod::WaitResult() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   event_.Wait();
   return result_;
 }
 
-GnomeKeyringResult GKRMethod::WaitResult(PasswordFormList* forms) {
+GnomeKeyringResult GKRMethod::WaitResult(
+    ScopedVector<autofill::PasswordForm>* forms) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   event_.Wait();
   if (forms->empty()) {
     // Normal case. Avoid extra allocation by swapping.
     forms->swap(forms_);
   } else {
     // Rare case. Append forms_ to *forms.
     forms->insert(forms->end(), forms_.begin(), forms_.end());
-    forms_.clear();
+    forms_.weak_clear();
   }
   return result_;
 }
 
 // static
 void GKRMethod::AppendString(GKRMethod::ScopedAttributeList* list,
                              const char* name,
                              const char* value) {
   gnome_keyring_attribute_list_append_string(list->get(), name, value);
 }
@@ skipping 68 matching lines @@
   // element, and signon_realm first, remove that, and then add the new entry.
   // We'd add the new one first, and then delete the original, but then the
   // delete might actually delete the newly-added entry!
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::AddLoginSearch,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   ScopedVector<autofill::PasswordForm> forms;
-  GnomeKeyringResult result = method.WaitResult(&forms.get());
+  GnomeKeyringResult result = method.WaitResult(&forms);
   if (result != GNOME_KEYRING_RESULT_OK &&
       result != GNOME_KEYRING_RESULT_NO_MATCH) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message(result);
     return password_manager::PasswordStoreChangeList();
   }
   password_manager::PasswordStoreChangeList changes;
   if (forms.size() > 0) {
     if (forms.size() > 1) {
       LOG(WARNING) << "Adding login when there are " << forms.size()
@@ skipping 23 matching lines @@
   // original, but then the delete might actually delete the newly-added entry!
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(changes);
   changes->clear();
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::UpdateLoginSearch,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   ScopedVector<autofill::PasswordForm> forms;
-  GnomeKeyringResult result = method.WaitResult(&forms.get());
+  GnomeKeyringResult result = method.WaitResult(&forms);
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message(result);
     return false;
   }
 
   bool removed = false;
   for (size_t i = 0; i < forms.size(); ++i) {
     if (*forms[i] != form) {
       RemoveLogin(*forms[i]);
@@ skipping 38 matching lines @@
       delete_begin, delete_end, CREATION_TIMESTAMP, changes);
 }
 
 bool NativeBackendGnome::RemoveLoginsSyncedBetween(
     base::Time delete_begin,
     base::Time delete_end,
     password_manager::PasswordStoreChangeList* changes) {
   return RemoveLoginsBetween(delete_begin, delete_end, SYNC_TIMESTAMP, changes);
 }
 
-bool NativeBackendGnome::GetLogins(const PasswordForm& form,
-                                   PasswordFormList* forms) {
+bool NativeBackendGnome::GetLogins(
+    const PasswordForm& form,
+    ScopedVector<autofill::PasswordForm>* forms) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetLogins,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message(result);
     return false;
   }
   return true;
 }
 
-bool NativeBackendGnome::GetAutofillableLogins(PasswordFormList* forms) {
-  return GetLoginsList(forms, true);
+bool NativeBackendGnome::GetAutofillableLogins(
+    ScopedVector<autofill::PasswordForm>* forms) {
+  return GetLoginsList(true, forms);
 }
 
-bool NativeBackendGnome::GetBlacklistLogins(PasswordFormList* forms) {
-  return GetLoginsList(forms, false);
+bool NativeBackendGnome::GetBlacklistLogins(
+    ScopedVector<autofill::PasswordForm>* forms) {
+  return GetLoginsList(false, forms);
 }
 
-bool NativeBackendGnome::GetLoginsList(PasswordFormList* forms,
-                                       bool autofillable) {
+bool NativeBackendGnome::GetLoginsList(
+    bool autofillable,
+    ScopedVector<autofill::PasswordForm>* forms) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   uint32_t blacklisted_by_user = !autofillable;
 
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetLoginsList,
                                      base::Unretained(&method),
                                      blacklisted_by_user, app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message(result);
     return false;
   }
   return true;
 }
 
-bool NativeBackendGnome::GetAllLogins(PasswordFormList* forms) {
+bool NativeBackendGnome::GetAllLogins(
+    ScopedVector<autofill::PasswordForm>* forms) {
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetAllLogins,
                                      base::Unretained(&method),
                                      app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
                << gnome_keyring_result_to_message(result);
     return false;
   }
   return true;
 }
 
-bool NativeBackendGnome::GetLoginsBetween(base::Time get_begin,
-                                          base::Time get_end,
-                                          TimestampToCompare date_to_compare,
-                                          PasswordFormList* forms) {
+bool NativeBackendGnome::GetLoginsBetween(
+    base::Time get_begin,
+    base::Time get_end,
+    TimestampToCompare date_to_compare,
+    ScopedVector<autofill::PasswordForm>* forms) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   // We could walk the list and add items as we find them, but it is much
   // easier to build the list and then filter the results.
-  PasswordFormList all_forms;
+  ScopedVector<autofill::PasswordForm> all_forms;
   if (!GetAllLogins(&all_forms))
     return false;
 
   base::Time autofill::PasswordForm::*date_member =
       date_to_compare == CREATION_TIMESTAMP
           ? &autofill::PasswordForm::date_created
           : &autofill::PasswordForm::date_synced;
-  for (size_t i = 0; i < all_forms.size(); ++i) {
-    if (get_begin <= all_forms[i]->*date_member &&
-        (get_end.is_null() || all_forms[i]->*date_member < get_end)) {
-      forms->push_back(all_forms[i]);
-    } else {
-      delete all_forms[i];
+  for (auto& saved_form : all_forms) {
+    if (get_begin <= saved_form->*date_member &&
+        (get_end.is_null() || saved_form->*date_member < get_end)) {
+      forms->push_back(saved_form);
+      saved_form = nullptr;
     }
   }
 
   return true;
 }
 
 bool NativeBackendGnome::RemoveLoginsBetween(
     base::Time get_begin,
     base::Time get_end,
     TimestampToCompare date_to_compare,
     password_manager::PasswordStoreChangeList* changes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(changes);
   changes->clear();
   // We could walk the list and delete items as we find them, but it is much
   // easier to build the list and use RemoveLogin() to delete them.
   ScopedVector<autofill::PasswordForm> forms;
-  if (!GetLoginsBetween(get_begin, get_end, date_to_compare, &forms.get()))
+  if (!GetLoginsBetween(get_begin, get_end, date_to_compare, &forms))
     return false;
 
   bool ok = true;
   for (size_t i = 0; i < forms.size(); ++i) {
     if (RemoveLogin(*forms[i])) {
       changes->push_back(password_manager::PasswordStoreChange(
           password_manager::PasswordStoreChange::REMOVE, *forms[i]));
     } else {
       ok = false;
     }
   }
   return ok;
 }
 
 std::string NativeBackendGnome::GetProfileSpecificAppString() const {
   // Originally, the application string was always just "chrome" and used only
   // so that we had *something* to search for since GNOME Keyring won't search
   // for nothing. Now we use it to distinguish passwords for different profiles.
   return base::StringPrintf("%s-%d", kGnomeKeyringAppString, profile_id_);
 }