PasswordForm -> FormDigest for GetLogins

chrome/browser/password_manager/native_backend_libsecret.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 "chrome/browser/password_manager/native_backend_libsecret.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <libsecret/secret.h>
 
 #include <limits>
 #include <list>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_util.h"
 #include "url/origin.h"
 
 using autofill::PasswordForm;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
+using password_manager::PasswordStore;
 
 namespace {
 const char kEmptyString[] = "";
 const int kMaxPossibleTimeTValue = std::numeric_limits<int>::max();
 }  // namespace
 
 namespace {
 
 const char kLibsecretAppString[] = "chrome";
 
@@ skipping 251 matching lines @@
       form->skip_zero_click = true;
       if (!UpdateLogin(*form, changes))
         return false;
     }
   }
 
   return true;
 }
 
 bool NativeBackendLibsecret::GetLogins(
-    const PasswordForm& form,
+    const PasswordStore::FormDigest& form,
     ScopedVector<autofill::PasswordForm>* forms) {
   return GetLoginsList(&form, ALL_LOGINS, forms);
 }
 
 bool NativeBackendLibsecret::AddUpdateLoginSearch(
     const autofill::PasswordForm& lookup_form,
     ScopedVector<autofill::PasswordForm>* forms) {
   LibsecretAttributesBuilder attrs;
   attrs.Append("origin_url", lookup_form.origin.spec());
   attrs.Append("username_element", UTF16ToUTF8(lookup_form.username_element));
   attrs.Append("username_value", UTF16ToUTF8(lookup_form.username_value));
   attrs.Append("password_element", UTF16ToUTF8(lookup_form.password_element));
   attrs.Append("signon_realm", lookup_form.signon_realm);
   attrs.Append("application", app_string_);
 
   GError* error = nullptr;
   GList* found = LibsecretLoader::secret_service_search_sync(
       nullptr,  // default secret service
       &kLibsecretSchema, attrs.Get(), SECRET_SEARCH_ALL,
       nullptr,  // no cancellable ojbect
       &error);
   if (error) {
     LOG(ERROR) << "Unable to get logins " << error->message;
     g_error_free(error);
     if (found)
       g_list_free(found);
     return false;
   }
 
-  *forms = ConvertFormList(found, &lookup_form);
+  PasswordStore::FormDigest form = {

[dvadym, 2016/07/20 13:43:02]

nit: Why don't to use constructor of FormDigest that takes PasswordForm?

[vabr (Chromium), 2016/07/20 14:13:06]

Done.

+      lookup_form.scheme, lookup_form.signon_realm, lookup_form.origin};
+  *forms = ConvertFormList(found, &form);
   return true;
 }
 
 bool NativeBackendLibsecret::RawAddLogin(const PasswordForm& form) {
   int64_t date_created = form.date_created.ToInternalValue();
   // If we are asked to save a password with 0 date, use the current time.
   // We don't want to actually save passwords as though on January 1, 1601.
   if (!date_created)
     date_created = base::Time::Now().ToInternalValue();
   int64_t date_synced = form.date_synced.ToInternalValue();
@@ skipping 53 matching lines @@
     ScopedVector<autofill::PasswordForm>* forms) {
   return GetLoginsList(nullptr, BLACKLISTED_LOGINS, forms);
 }
 
 bool NativeBackendLibsecret::GetAllLogins(
     ScopedVector<autofill::PasswordForm>* forms) {
   return GetLoginsList(nullptr, ALL_LOGINS, forms);
 }
 
 bool NativeBackendLibsecret::GetLoginsList(
-    const PasswordForm* lookup_form,
+    const PasswordStore::FormDigest* lookup_form,
     GetLoginsListOptions options,
     ScopedVector<autofill::PasswordForm>* forms) {
   LibsecretAttributesBuilder attrs;
   attrs.Append("application", app_string_);
   if (options != ALL_LOGINS)
     attrs.Append("blacklisted_by_user", options == BLACKLISTED_LOGINS);
   if (lookup_form &&
       !password_manager::ShouldPSLDomainMatchingApply(
           password_manager::GetRegistryControlledDomain(
               GURL(lookup_form->signon_realm))) &&
@@ skipping 75 matching lines @@
 
   for (size_t i = 0; i < forms.size(); ++i) {
     if (!RemoveLogin(*forms[i], changes))
       return false;
   }
   return true;
 }
 
 ScopedVector<autofill::PasswordForm> NativeBackendLibsecret::ConvertFormList(
     GList* found,
-    const PasswordForm* lookup_form) {
+    const PasswordStore::FormDigest* lookup_form) {
   ScopedVector<autofill::PasswordForm> forms;
   password_manager::PSLDomainMatchMetric psl_domain_match_metric =
       password_manager::PSL_DOMAIN_MATCH_NONE;
   GError* error = nullptr;
   const bool allow_psl_match =
       lookup_form && password_manager::ShouldPSLDomainMatchingApply(
                          password_manager::GetRegistryControlledDomain(
                              GURL(lookup_form->signon_realm)));
   for (GList* element = g_list_first(found); element != nullptr;
        element = g_list_next(element)) {
@@ skipping 44 matching lines @@
   if (lookup_form) {
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               allow_psl_match
                                   ? psl_domain_match_metric
                                   : password_manager::PSL_DOMAIN_MATCH_NOT_USED,
                               password_manager::PSL_DOMAIN_MATCH_COUNT);
   }
   g_list_free(found);
   return forms;
 }