Serialize form_data in Gnome keyring password store service.

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 <dlfcn.h>
 #include <list>
 
 #include "base/basictypes.h"
@@ skipping 73 matching lines @@
   libsecret_loaded = true;
   // We leak the library handle. That's OK: this function is called only once.
   return true;
 }
 
 namespace {
 
 const char kLibsecretAppString[] = "chrome";
 
 // Schema is analagous to the fields in PasswordForm.
-// TODO(gcasto): Adding 'form_data' would be nice, but we would need to
-// serialize in a way that is guaranteed to not have any embedded NULLs. Pickle
-// doesn't make this guarantee, so we just don't serialize this field. Since
-// it's only used to crowd source data collection it doesn't matter that much
-// if it's not available on this platform.
 const SecretSchema kLibsecretSchema = {
     "chrome_libsecret_password_schema",
     // We have to use SECRET_SCHEMA_DONT_MATCH_NAME in order to get old
     // passwords stored with gnome_keyring.
     SECRET_SCHEMA_DONT_MATCH_NAME,
     {{"origin_url", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"action_url", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"username_element", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"username_value", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"password_element", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"submit_element", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"signon_realm", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"ssl_valid", SECRET_SCHEMA_ATTRIBUTE_INTEGER},
      {"preferred", SECRET_SCHEMA_ATTRIBUTE_INTEGER},
      {"date_created", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"blacklisted_by_user", SECRET_SCHEMA_ATTRIBUTE_INTEGER},
      {"scheme", SECRET_SCHEMA_ATTRIBUTE_INTEGER},
      {"type", SECRET_SCHEMA_ATTRIBUTE_INTEGER},
      {"times_used", SECRET_SCHEMA_ATTRIBUTE_INTEGER},
      {"date_synced", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"display_name", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"avatar_url", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"federation_url", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {"skip_zero_click", SECRET_SCHEMA_ATTRIBUTE_INTEGER},
      {"generation_upload_status", SECRET_SCHEMA_ATTRIBUTE_INTEGER},
+     {"form_data", SECRET_SCHEMA_ATTRIBUTE_STRING},
      // This field is always "chrome-profile_id" so that we can search for it.
      {"application", SECRET_SCHEMA_ATTRIBUTE_STRING},
      {nullptr, SECRET_SCHEMA_ATTRIBUTE_STRING}}};
 
 const char* GetStringFromAttributes(GHashTable* attrs, const char* keyname) {
   gpointer value = g_hash_table_lookup(attrs, keyname);
   return value ? static_cast<char*>(value) : kEmptyString;
 }
 
 uint32_t GetUintFromAttributes(GHashTable* attrs, const char* keyname) {
@@ skipping 53 matching lines @@
                       &date_synced);
   form->date_synced = base::Time::FromInternalValue(date_synced);
   form->display_name =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "display_name"));
   form->avatar_url = GURL(GetStringFromAttributes(attrs, "avatar_url"));
   form->federation_url = GURL(GetStringFromAttributes(attrs, "federation_url"));
   form->skip_zero_click = GetUintFromAttributes(attrs, "skip_zero_click");
   form->generation_upload_status =
       static_cast<PasswordForm::GenerationUploadStatus>(
           GetUintFromAttributes(attrs, "generation_upload_status"));
-
+  DeserializeFormDataFromBase64String(
+      GetStringFromAttributes(attrs, "form_data"), &form->form_data);
   return form.Pass();
 }
 
 class LibsecretAttributesBuilder {
  public:
   LibsecretAttributesBuilder();
   ~LibsecretAttributesBuilder();
   void Append(const std::string& name, const std::string& value);
   void Append(const std::string& name, int64 value);
   // GHashTable, its keys and values returned from Get() are destroyed in
@@ skipping 201 matching lines @@
   ConvertFormList(found, &lookup_form, forms);
 }
 
 bool NativeBackendLibsecret::RawAddLogin(const PasswordForm& form) {
   int64 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 date_synced = form.date_synced.ToInternalValue();
+  std::string form_data;
+  SerializeFormDataToBase64String(form.form_data, &form_data);
   GError* error = nullptr;
   secret_password_store_sync(
       &kLibsecretSchema,
       nullptr,                     // Default collection.
       form.origin.spec().c_str(),  // Display name.
       UTF16ToUTF8(form.password_value).c_str(),
       nullptr,  // no cancellable ojbect
       &error,
       "origin_url", form.origin.spec().c_str(),
       "action_url", form.action.spec().c_str(),
       "username_element", UTF16ToUTF8(form.username_element).c_str(),
       "username_value", UTF16ToUTF8(form.username_value).c_str(),
       "password_element", UTF16ToUTF8(form.password_element).c_str(),
       "submit_element", UTF16ToUTF8(form.submit_element).c_str(),
       "signon_realm", form.signon_realm.c_str(),
       "ssl_valid", form.ssl_valid,
       "preferred", form.preferred,
       "date_created", base::Int64ToString(date_created).c_str(),
       "blacklisted_by_user", form.blacklisted_by_user,
       "type", form.type,
       "times_used", form.times_used,
       "scheme", form.scheme,
       "date_synced", base::Int64ToString(date_synced).c_str(),
       "display_name", UTF16ToUTF8(form.display_name).c_str(),
       "avatar_url", form.avatar_url.spec().c_str(),
       "federation_url", form.federation_url.spec().c_str(),
       "skip_zero_click", form.skip_zero_click,
       "generation_upload_status", form.generation_upload_status,
+      "form_data", form_data.c_str(),
       "application", app_string_.c_str(), nullptr);
 
   if (error) {
     VLOG(1) << "Libsecret add raw login failed: " << error->message;
     g_error_free(error);
     return false;
   }
   return true;
 }
 
@@ skipping 152 matching lines @@
   return true;
 }
 
 std::string NativeBackendLibsecret::GetProfileSpecificAppString(
     LocalProfileId id) {
   // 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", kLibsecretAppString, id);
 }